Clean up part of CXFA_Node class

xfa/fxfa/parser/xfa_object_imp.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/fxfa/parser/xfa_object.h"
 
 #include <memory>
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "third_party/base/stl_util.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/crt/fgas_system.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/parser/cxfa_occur.h"
 #include "xfa/fxfa/parser/xfa_basic_imp.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_document_layout_imp.h"
 #include "xfa/fxfa/parser/xfa_localemgr.h"
 #include "xfa/fxfa/parser/xfa_parser.h"
 #include "xfa/fxfa/parser/xfa_parser_imp.h"
 #include "xfa/fxfa/parser/xfa_script.h"
 #include "xfa/fxfa/parser/xfa_script_imp.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
 #include "xfa/fxjse/cfxjse_arguments.h"
 
+namespace {
+
+void XFA_DeleteWideString(void* pData) {
+  delete static_cast<CFX_WideString*>(pData);
+}
+
+void XFA_CopyWideString(void*& pData) {
+  if (pData) {
+    CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData);
+    pData = pNewData;
+  }
+}
+
+XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {XFA_DeleteWideString,
+                                                         XFA_CopyWideString};
+
+XFA_OBJECTTYPE XFA_GetElementObjectType(XFA_ELEMENT eElement) {
+  return static_cast<XFA_OBJECTTYPE>(XFA_GetElementByID(eElement)->eObjectType);
+}
+
+void XFA_DataNodeDeleteBindItem(void* pData) {
+  delete static_cast<CXFA_NodeArray*>(pData);
+}
+
+XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {
+    XFA_DataNodeDeleteBindItem, nullptr};
+
+}  // namespace
+
 CXFA_Object::CXFA_Object(CXFA_Document* pDocument, uint32_t uFlags)
     : m_pDocument(pDocument), m_uFlags(uFlags) {}
+
 void CXFA_Object::GetClassName(CFX_WideStringC& wsName) const {
   wsName = XFA_GetElementByID(GetClassID())->pName;
 }
+
 uint32_t CXFA_Object::GetClassHashCode() const {
   return XFA_GetElementByID(GetClassID())->uHash;
 }
+
 XFA_ELEMENT CXFA_Object::GetClassID() const {
-  if (IsNode()) {
+  if (IsNode())
     return AsNode()->GetClassID();
-  }
-  if (IsOrdinaryObject()) {
+  if (IsOrdinaryObject())
     return AsOrdinaryObject()->GetClassID();
-  }
-  if (IsNodeList()) {
+  if (IsNodeList())
     return AsNodeList()->GetClassID();
-  }
-  if (IsOrdinaryList()) {
+  if (IsOrdinaryList())
     return XFA_ELEMENT_List;
-  }
   ASSERT(FALSE);
   return (XFA_ELEMENT)0;
 }
+
 void CXFA_Object::Script_ObjectClass_ClassName(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC className;
     GetClassName(className);
     FXJSE_Value_SetUTF8String(
         pValue,
         FX_UTF8Encode(className.c_str(), className.GetLength()).AsStringC());
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   }
 }
+
 void CXFA_Object::ThrowScriptErrorMessage(int32_t iStringID, ...) {
   IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
   ASSERT(pAppProvider);
   CFX_WideString wsFormat;
   pAppProvider->LoadString(iStringID, wsFormat);
   CFX_WideString wsMessage;
   va_list arg_ptr;
   va_start(arg_ptr, iStringID);
   wsMessage.FormatV(wsFormat.c_str(), arg_ptr);
   va_end(arg_ptr);
   FXJSE_ThrowMessage(
       "", FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
 }
 
-static void XFA_DeleteWideString(void* pData) {
-  delete static_cast<CFX_WideString*>(pData);
-}
-
-static void XFA_CopyWideString(void*& pData) {
-  if (pData) {
-    CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData);
-    pData = pNewData;
-  }
-}
-static XFA_MAPDATABLOCKCALLBACKINFO deleteWideStringCallBack = {
-    XFA_DeleteWideString, XFA_CopyWideString};
-static XFA_OBJECTTYPE XFA_GetElementObjectType(XFA_ELEMENT eElement) {
-  return (XFA_OBJECTTYPE)XFA_GetElementByID(eElement)->eObjectType;
-}
 CXFA_Node::CXFA_Node(CXFA_Document* pDoc,
                      uint16_t ePacket,
                      XFA_ELEMENT eElement)
     : CXFA_Object(pDoc, XFA_GetElementObjectType(eElement)),
       m_pNext(nullptr),
       m_pChild(nullptr),
       m_pLastChild(nullptr),
       m_pParent(nullptr),
       m_pXMLNode(nullptr),
       m_eNodeClass(eElement),
       m_ePacket(ePacket),
       m_dwNameHash(0),
       m_pAuxNode(nullptr),
       m_pMapModuleData(nullptr) {
   ASSERT(m_pDocument);
 }
+
 CXFA_Node::~CXFA_Node() {
-  ASSERT(m_pParent == NULL);
+  ASSERT(!m_pParent);
   RemoveMapModuleKey();
-  CXFA_Node *pNext, *pNode = m_pChild;
+  CXFA_Node* pNode = m_pChild;
   while (pNode) {
-    pNext = pNode->m_pNext;
-    pNode->m_pParent = NULL;
+    CXFA_Node* pNext = pNode->m_pNext;
+    pNode->m_pParent = nullptr;
     delete pNode;
     pNode = pNext;
   }
-  if (m_pXMLNode && HasFlag(XFA_NODEFLAG_OwnXMLNode)) {
+  if (m_pXMLNode && HasFlag(XFA_NODEFLAG_OwnXMLNode))
     m_pXMLNode->Release();
-  }
 }
+
 CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive) {
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   CXFA_Node* pClone = pFactory->CreateNode(m_ePacket, m_eNodeClass);
-  if (!pClone) {
-    return NULL;
-  }
+  if (!pClone)
+    return nullptr;
+
   MergeAllData(pClone);
   pClone->UpdateNameHash();
   if (IsNeedSavingXMLNode()) {
-    CFDE_XMLNode* pCloneXML = NULL;
+    CFDE_XMLNode* pCloneXML = nullptr;
     if (IsAttributeInXML()) {
       CFX_WideString wsName;
       GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
       CFDE_XMLElement* pCloneXMLElement = new CFDE_XMLElement(wsName);
       CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pCloneXMLElement->SetTextData(CFX_WideString(wsValue));
       }
       pCloneXML = pCloneXMLElement;
-      pCloneXMLElement = NULL;
+      pCloneXMLElement = nullptr;
       pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       pCloneXML = m_pXMLNode->Clone(FALSE);
     }
     pClone->SetXMLMappingNode(pCloneXML);
     pClone->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
   }
   if (bRecursive) {
     for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild;
          pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pClone->InsertChild(pChild->Clone(bRecursive));
     }
   }
   pClone->SetFlag(XFA_NODEFLAG_Initialized, true);
-  pClone->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
+  pClone->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
   return pClone;
 }
+
 CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem) const {
   switch (eItem) {
     case XFA_NODEITEM_NextSibling:
       return m_pNext;
     case XFA_NODEITEM_FirstChild:
       return m_pChild;
     case XFA_NODEITEM_Parent:
       return m_pParent;
     case XFA_NODEITEM_PrevSibling:
       if (m_pParent) {
         CXFA_Node* pSibling = m_pParent->m_pChild;
-        CXFA_Node* pPrev = NULL;
+        CXFA_Node* pPrev = nullptr;
         while (pSibling && pSibling != this) {
           pPrev = pSibling;
           pSibling = pSibling->m_pNext;
         }
         return pPrev;
       }
-      return NULL;
+      return nullptr;
     default:
       break;
   }
-  return NULL;
+  return nullptr;
 }
+
 CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem,
                                   XFA_OBJECTTYPE eType) const {
-  CXFA_Node* pNode = NULL;
+  CXFA_Node* pNode = nullptr;
   switch (eItem) {
     case XFA_NODEITEM_NextSibling:
       pNode = m_pNext;
       if (eType != XFA_OBJECTTYPEMASK) {
-        while (pNode && pNode->GetObjectType() != eType) {
+        while (pNode && pNode->GetObjectType() != eType)
           pNode = pNode->m_pNext;
-        }
       }
       break;
     case XFA_NODEITEM_FirstChild:
       pNode = m_pChild;
       if (eType != XFA_OBJECTTYPEMASK) {
-        while (pNode && pNode->GetObjectType() != eType) {
+        while (pNode && pNode->GetObjectType() != eType)
           pNode = pNode->m_pNext;
-        }
       }
       break;
     case XFA_NODEITEM_Parent:
       pNode = m_pParent;
       if (eType != XFA_OBJECTTYPEMASK) {
-        while (pNode && pNode->GetObjectType() != eType) {
+        while (pNode && pNode->GetObjectType() != eType)
           pNode = pNode->m_pParent;
-        }
       }
       break;
     case XFA_NODEITEM_PrevSibling:
       if (m_pParent) {
         CXFA_Node* pSibling = m_pParent->m_pChild;
         while (pSibling && pSibling != this) {
           if (eType == XFA_OBJECTTYPEMASK ||
               eType == pSibling->GetObjectType()) {
             pNode = pSibling;
           }
           pSibling = pSibling->m_pNext;
         }
       }
       break;
     default:
       break;
   }
   return pNode;
 }
+
 int32_t CXFA_Node::GetNodeList(CXFA_NodeArray& nodes,
                                uint32_t dwTypeFilter,
                                XFA_ELEMENT eElementFilter,
                                int32_t iLevel) {
   if (--iLevel < 0) {
     return nodes.GetSize();
   }
   if (eElementFilter != XFA_ELEMENT_UNKNOWN) {
     CXFA_Node* pChild = m_pChild;
     while (pChild) {
       if (pChild->GetClassID() == eElementFilter) {
         nodes.Add(pChild);
         if (iLevel > 0) {
           GetNodeList(nodes, dwTypeFilter, eElementFilter, iLevel);
         }
       }
       pChild = pChild->m_pNext;
     }
   } else if (dwTypeFilter ==
              (XFA_NODEFILTER_Children | XFA_NODEFILTER_Properties)) {
     CXFA_Node* pChild = m_pChild;
     while (pChild) {
       nodes.Add(pChild);
       if (iLevel > 0) {
         GetNodeList(nodes, dwTypeFilter, eElementFilter, iLevel);
       }
       pChild = pChild->m_pNext;
     }
   } else if (dwTypeFilter != 0) {
-    FX_BOOL bFilterChildren = (dwTypeFilter & XFA_NODEFILTER_Children) != 0;
-    FX_BOOL bFilterProperties = (dwTypeFilter & XFA_NODEFILTER_Properties) != 0;
-    FX_BOOL bFilterOneOfProperties =
-        (dwTypeFilter & XFA_NODEFILTER_OneOfProperty) != 0;
+    bool bFilterChildren = !!(dwTypeFilter & XFA_NODEFILTER_Children);
+    bool bFilterProperties = !!(dwTypeFilter & XFA_NODEFILTER_Properties);
+    bool bFilterOneOfProperties =
+        !!(dwTypeFilter & XFA_NODEFILTER_OneOfProperty);
     CXFA_Node* pChild = m_pChild;
     while (pChild) {
       const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
           GetClassID(), pChild->GetClassID(), XFA_XDPPACKET_UNKNOWN);
       if (pProperty) {
         if (bFilterProperties) {
           nodes.Add(pChild);
         } else if (bFilterOneOfProperties &&
                    (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
           nodes.Add(pChild);
         } else if (bFilterChildren &&
                    (pChild->GetClassID() == XFA_ELEMENT_Variables ||
                     pChild->GetClassID() == XFA_ELEMENT_PageSet)) {
           nodes.Add(pChild);
         }
-      } else {
-        if (bFilterChildren) {
-          nodes.Add(pChild);
-        }
+      } else if (bFilterChildren) {
+        nodes.Add(pChild);
       }
       pChild = pChild->m_pNext;
     }
     if (bFilterOneOfProperties && nodes.GetSize() < 1) {
       int32_t iProperties = 0;
       const XFA_PROPERTY* pProperty =
           XFA_GetElementProperties(GetClassID(), iProperties);
-      if (pProperty == NULL || iProperties < 1) {
+      if (!pProperty || iProperties < 1)
         return 0;
-      }
       for (int32_t i = 0; i < iProperties; i++) {
         if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) {
           CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
           const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(GetPacketID());
           CXFA_Node* pNewNode =
               pFactory->CreateNode(pPacket, (XFA_ELEMENT)pProperty[i].eName);
-          if (!pNewNode) {
+          if (!pNewNode)
             break;
-          }
-          InsertChild(pNewNode, NULL);
+          InsertChild(pNewNode, nullptr);
           pNewNode->SetFlag(XFA_NODEFLAG_Initialized, true);
           nodes.Add(pNewNode);
           break;
         }
       }
     }
   }
   return nodes.GetSize();
 }
+
 CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_ELEMENT eElement,
                                            uint32_t dwFlags) {
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eElement);
   pNode->SetFlag(dwFlags, true);
   return pNode;
 }
+
 CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) {
   ASSERT(m_ePacket == XFA_XDPPACKET_Template);
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   CXFA_Node* pClone = pFactory->CreateNode(XFA_XDPPACKET_Form, m_eNodeClass);
-  if (!pClone) {
-    return NULL;
-  }
+  if (!pClone)
+    return nullptr;
+
   pClone->SetTemplateNode(this);
   pClone->UpdateNameHash();
   pClone->SetXMLMappingNode(GetXMLMappingNode());
   if (bRecursive) {
     for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild;
          pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pClone->InsertChild(pChild->CloneTemplateToForm(bRecursive));
     }
   }
   pClone->SetFlag(XFA_NODEFLAG_Initialized, true);
   return pClone;
 }
 
 CXFA_Node* CXFA_Node::GetTemplateNode() const {
   return m_pAuxNode;
 }
 
 void CXFA_Node::SetTemplateNode(CXFA_Node* pTemplateNode) {
   m_pAuxNode = pTemplateNode;
 }
+
 CXFA_Node* CXFA_Node::GetBindData() {
   ASSERT(GetPacketID() == XFA_XDPPACKET_Form);
   return static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
 }
+
 int32_t CXFA_Node::GetBindItems(CXFA_NodeArray& formItems) {
   if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
-    CXFA_NodeArray* pItems = NULL;
+    CXFA_NodeArray* pItems = nullptr;
     TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems);
     formItems.Copy(*pItems);
     return formItems.GetSize();
   }
   CXFA_Node* pFormNode =
       static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
-  if (pFormNode) {
+  if (pFormNode)
     formItems.Add(pFormNode);
-  }
   return formItems.GetSize();
 }
 
-static void XFA_DataNodeDeleteBindItem(void* pData) {
-  delete static_cast<CXFA_NodeArray*>(pData);
-}
-
-static XFA_MAPDATABLOCKCALLBACKINFO deleteBindItemCallBack = {
-    XFA_DataNodeDeleteBindItem, NULL};
 int32_t CXFA_Node::AddBindItem(CXFA_Node* pFormNode) {
   ASSERT(pFormNode);
   if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
-    CXFA_NodeArray* pItems = NULL;
+    CXFA_NodeArray* pItems = nullptr;
     TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems);
     ASSERT(pItems);
     if (pItems->Find(pFormNode) < 0) {
       pItems->Add(pFormNode);
     }
     return pItems->GetSize();
   }
   CXFA_Node* pOldFormItem =
       static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
   if (!pOldFormItem) {
     SetObject(XFA_ATTRIBUTE_BindingNode, pFormNode);
     return 1;
   } else if (pOldFormItem == pFormNode) {
     return 1;
   }
   CXFA_NodeArray* pItems = new CXFA_NodeArray;
   SetObject(XFA_ATTRIBUTE_BindingNode, pItems, &deleteBindItemCallBack);
   pItems->Add(pOldFormItem);
   pItems->Add(pFormNode);
   m_uFlags |= XFA_NODEFLAG_BindFormItems;
   return 2;
 }
+
 int32_t CXFA_Node::RemoveBindItem(CXFA_Node* pFormNode) {
   if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
-    CXFA_NodeArray* pItems = NULL;
+    CXFA_NodeArray* pItems = nullptr;
     TryObject(XFA_ATTRIBUTE_BindingNode, (void*&)pItems);
     ASSERT(pItems);
     int32_t iIndex = pItems->Find(pFormNode);
     int32_t iCount = pItems->GetSize();
     if (iIndex >= 0) {
-      if (iIndex != iCount - 1) {
+      if (iIndex != iCount - 1)
         pItems->SetAt(iIndex, pItems->GetAt(iCount - 1));
-      }
       pItems->RemoveAt(iCount - 1);
       if (iCount == 2) {
         CXFA_Node* pLastFormNode = pItems->GetAt(0);
         SetObject(XFA_ATTRIBUTE_BindingNode, pLastFormNode);
         m_uFlags &= ~XFA_NODEFLAG_BindFormItems;
       }
       iCount--;
     }
     return iCount;
   }
   CXFA_Node* pOldFormItem =
       static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
   if (pOldFormItem == pFormNode) {
-    SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
-    pOldFormItem = NULL;
+    SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
+    pOldFormItem = nullptr;
   }
-  return pOldFormItem == NULL ? 0 : 1;
+  return pOldFormItem ? 1 : 0;
 }
+
 FX_BOOL CXFA_Node::HasBindItem() {
-  return (GetPacketID() == XFA_XDPPACKET_Datasets) &&
-         GetObject(XFA_ATTRIBUTE_BindingNode) != NULL;
+  return GetPacketID() == XFA_XDPPACKET_Datasets &&
+         GetObject(XFA_ATTRIBUTE_BindingNode);
 }
+
 CXFA_WidgetData* CXFA_Node::GetWidgetData() {
   return (CXFA_WidgetData*)GetObject(XFA_ATTRIBUTE_WidgetData);
 }
+
 CXFA_WidgetData* CXFA_Node::GetContainerWidgetData() {
-  if (GetPacketID() != XFA_XDPPACKET_Form) {
-    return NULL;
-  }
+  if (GetPacketID() != XFA_XDPPACKET_Form)
+    return nullptr;
   XFA_ELEMENT classID = GetClassID();
-  if (classID == XFA_ELEMENT_ExclGroup) {
-    return NULL;
-  }
+  if (classID == XFA_ELEMENT_ExclGroup)
+    return nullptr;
   CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-  if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_ExclGroup) {
-    return NULL;
-  }
+  if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_ExclGroup)
+    return nullptr;
+
   if (classID == XFA_ELEMENT_Field) {
     CXFA_WidgetData* pFieldWidgetData = GetWidgetData();
     if (pFieldWidgetData &&
         pFieldWidgetData->GetChoiceListOpen() ==
             XFA_ATTRIBUTEENUM_MultiSelect) {
-      return NULL;
+      return nullptr;
     } else {
       CFX_WideString wsPicture;
       if (pFieldWidgetData) {
         pFieldWidgetData->GetPictureContent(wsPicture,
                                             XFA_VALUEPICTURE_DataBind);
       }
-      if (!wsPicture.IsEmpty()) {
+      if (!wsPicture.IsEmpty())
         return pFieldWidgetData;
-      }
       CXFA_Node* pDataNode = GetBindData();
-      if (!pDataNode) {
-        return NULL;
-      }
-      pFieldWidgetData = NULL;
+      if (!pDataNode)
+        return nullptr;
+      pFieldWidgetData = nullptr;
       CXFA_NodeArray formNodes;
       pDataNode->GetBindItems(formNodes);
       for (int32_t i = 0; i < formNodes.GetSize(); i++) {
         CXFA_Node* pFormNode = formNodes.GetAt(i);
-        if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
+        if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved))
           continue;
-        }
         pFieldWidgetData = pFormNode->GetWidgetData();
         if (pFieldWidgetData) {
           pFieldWidgetData->GetPictureContent(wsPicture,
                                               XFA_VALUEPICTURE_DataBind);
         }
-        if (!wsPicture.IsEmpty()) {
+        if (!wsPicture.IsEmpty())
           break;
-        }
-        pFieldWidgetData = NULL;
+        pFieldWidgetData = nullptr;
       }
       return pFieldWidgetData;
     }
   }
   CXFA_Node* pGrandNode =
-      pParentNode ? pParentNode->GetNodeItem(XFA_NODEITEM_Parent) : NULL;
+      pParentNode ? pParentNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr;
   CXFA_Node* pValueNode =
       (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_Value)
           ? pParentNode
-          : NULL;
+          : nullptr;
   if (!pValueNode) {
     pValueNode = (pGrandNode && pGrandNode->GetClassID() == XFA_ELEMENT_Value)
                      ? pGrandNode
-                     : NULL;
+                     : nullptr;
   }
   CXFA_Node* pParentOfValueNode =
-      pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : NULL;
+      pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr;
   return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData()
-                            : NULL;
+                            : nullptr;
 }
+
 FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) {
   CXFA_Node* pForm = GetDocument()->GetXFAObject(XFA_HASHCODE_Form)->AsNode();
   CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_ELEMENT_Subform);
   ASSERT(pTopSubform);
   CXFA_Node* pLocaleNode = this;
   FX_BOOL bLocale = FALSE;
   do {
     bLocale = pLocaleNode->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
     if (!bLocale) {
       pLocaleNode = pLocaleNode->GetNodeItem(XFA_NODEITEM_Parent);
     }
   } while (pLocaleNode && pLocaleNode != pTopSubform && !bLocale);
-  if (bLocale) {
-    return bLocale;
-  }
+  if (bLocale)
+    return TRUE;
   CXFA_Node* pConfig = ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Config));
   wsLocaleName = GetDocument()->GetLocalMgr()->GetConfigLocaleName(pConfig);
-  if (!wsLocaleName.IsEmpty()) {
-    bLocale = TRUE;
-  }
-  if (bLocale) {
-    return bLocale;
-  }
-  if (pTopSubform) {
-    bLocale = pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
-  }
-  if (bLocale) {
-    return bLocale;
+  if (!wsLocaleName.IsEmpty())
+    return TRUE;
+  if (pTopSubform &&
+      pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE)) {
+    return TRUE;
   }
   IFX_Locale* pLocale = GetDocument()->GetLocalMgr()->GetDefLocale();
   if (pLocale) {
     wsLocaleName = pLocale->GetName();
-    bLocale = TRUE;
+    return TRUE;
   }
-  return bLocale;
+  return FALSE;
 }
+
 XFA_ATTRIBUTEENUM CXFA_Node::GetIntact() {
   XFA_ELEMENT eElement = GetClassID();
   CXFA_Node* pKeep = GetFirstChildByClass(XFA_ELEMENT_Keep);
   XFA_ATTRIBUTEENUM eLayoutType = GetEnum(XFA_ATTRIBUTE_Layout);
   if (pKeep) {
     XFA_ATTRIBUTEENUM eIntact;
     if (pKeep->TryEnum(XFA_ATTRIBUTE_Intact, eIntact, FALSE)) {
       if (eIntact == XFA_ATTRIBUTEENUM_None &&
           eLayoutType == XFA_ATTRIBUTEENUM_Row &&
           m_pDocument->GetCurVersionMode() < XFA_VERSION_208) {
         CXFA_Node* pPreviewRow =
             GetNodeItem(XFA_NODEITEM_PrevSibling, XFA_OBJECTTYPE_ContainerNode);
         if (pPreviewRow &&
             pPreviewRow->GetEnum(XFA_ATTRIBUTE_Layout) ==
                 XFA_ATTRIBUTEENUM_Row) {
           XFA_ATTRIBUTEENUM eValue;
-          if (pKeep->TryEnum(XFA_ATTRIBUTE_Previous, eValue, FALSE)) {
-            if (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
-                eValue == XFA_ATTRIBUTEENUM_PageArea) {
-              return XFA_ATTRIBUTEENUM_ContentArea;
-            }
+          if (pKeep->TryEnum(XFA_ATTRIBUTE_Previous, eValue, FALSE) &&
+              (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
+               eValue == XFA_ATTRIBUTEENUM_PageArea)) {
+            return XFA_ATTRIBUTEENUM_ContentArea;
           }
-          CXFA_Node* pKeep =
+          CXFA_Node* pNode =
               pPreviewRow->GetFirstChildByClass(XFA_ELEMENT_Keep);
-          if (pKeep) {
-            if (pKeep->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE)) {
-              if (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
-                  eValue == XFA_ATTRIBUTEENUM_PageArea) {
-                return XFA_ATTRIBUTEENUM_ContentArea;
-              }
-            }
+          if (pNode && pNode->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE) &&
+              (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
+               eValue == XFA_ATTRIBUTEENUM_PageArea)) {
+            return XFA_ATTRIBUTEENUM_ContentArea;
           }
         }
       }
       return eIntact;
     }
   }
   switch (eElement) {
     case XFA_ELEMENT_Subform:
       switch (eLayoutType) {
         case XFA_ATTRIBUTEENUM_Position:
         case XFA_ATTRIBUTEENUM_Row:
           return XFA_ATTRIBUTEENUM_ContentArea;
         case XFA_ATTRIBUTEENUM_Tb:
         case XFA_ATTRIBUTEENUM_Table:
         case XFA_ATTRIBUTEENUM_Lr_tb:
         case XFA_ATTRIBUTEENUM_Rl_tb:
           return XFA_ATTRIBUTEENUM_None;
         default:
           break;
       }
       break;
     case XFA_ELEMENT_Field: {
       CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
-      if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_PageArea) {
+      if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_PageArea)
         return XFA_ATTRIBUTEENUM_ContentArea;
-      }
       if (pParentNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
         XFA_ATTRIBUTEENUM eParLayout =
             pParentNode->GetEnum(XFA_ATTRIBUTE_Layout);
         if (eParLayout == XFA_ATTRIBUTEENUM_Position ||
             eParLayout == XFA_ATTRIBUTEENUM_Row ||
             eParLayout == XFA_ATTRIBUTEENUM_Table) {
           return XFA_ATTRIBUTEENUM_None;
         }
         XFA_VERSION version = m_pDocument->GetCurVersionMode();
         if (eParLayout == XFA_ATTRIBUTEENUM_Tb && version < XFA_VERSION_208) {
           CXFA_Measurement measureH;
-          if (TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE)) {
+          if (TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE))
             return XFA_ATTRIBUTEENUM_ContentArea;
-          }
         }
         return XFA_ATTRIBUTEENUM_None;
       }
       return XFA_ATTRIBUTEENUM_ContentArea;
     }
     case XFA_ELEMENT_Draw:
       return XFA_ATTRIBUTEENUM_ContentArea;
     default:
       break;
   }
   return XFA_ATTRIBUTEENUM_None;
 }
+
 CXFA_Node* CXFA_Node::GetDataDescriptionNode() {
-  if (m_ePacket == XFA_XDPPACKET_Datasets) {
+  if (m_ePacket == XFA_XDPPACKET_Datasets)
     return m_pAuxNode;
-  }
-  return NULL;
+  return nullptr;
 }
+
 void CXFA_Node::SetDataDescriptionNode(CXFA_Node* pDataDescriptionNode) {
   ASSERT(m_ePacket == XFA_XDPPACKET_Datasets);
   m_pAuxNode = pDataDescriptionNode;
 }
+
 void CXFA_Node::Script_TreeClass_ResolveNode(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
+  if (!pScriptContext)
     return;
-  }
   CXFA_Node* refNode = this;
-  if (refNode->GetClassID() == XFA_ELEMENT_Xfa) {
+  if (refNode->GetClassID() == XFA_ELEMENT_Xfa)
     refNode = ToNode(pScriptContext->GetThisObject());
-  }
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   XFA_RESOLVENODE_RS resoveNodeRS;
   int32_t iRet = pScriptContext->ResolveObjects(
       refNode, wsExpression.AsStringC(), resoveNodeRS, dwFlag);
-  if (iRet < 1) {
+  if (iRet < 1)
     return FXJSE_Value_SetNull(pArguments->GetReturnValue());
-  }
   if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
     CXFA_Object* pNode = resoveNodeRS.nodes[0];
     FXJSE_Value_Set(pArguments->GetReturnValue(),
                     pScriptContext->GetJSValueFromMap(pNode));
   } else {
     const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo =
         resoveNodeRS.pScriptAttribute;
     if (lpAttributeInfo && lpAttributeInfo->eValueType == XFA_SCRIPT_Object) {
       std::unique_ptr<CFXJSE_Value> pValue(
           new CFXJSE_Value(pScriptContext->GetRuntime()));
       (resoveNodeRS.nodes[0]->*(lpAttributeInfo->lpfnCallback))(
           pValue.get(), FALSE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
       FXJSE_Value_Set(pArguments->GetReturnValue(), pValue.get());
     } else {
       FXJSE_Value_SetNull(pArguments->GetReturnValue());
     }
   }
 }
+
 void CXFA_Node::Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"resolveNodes");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
-  if (!pValue) {
+  if (!pValue)
     return;
-  }
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   CXFA_Node* refNode = this;
-  if (refNode->GetClassID() == XFA_ELEMENT_Xfa) {
+  if (refNode->GetClassID() == XFA_ELEMENT_Xfa)
     refNode = ToNode(m_pDocument->GetScriptContext()->GetThisObject());
-  }
   Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag, refNode);
 }
+
 void CXFA_Node::Script_Som_ResolveNodeList(CFXJSE_Value* pValue,
                                            CFX_WideString wsExpression,
                                            uint32_t dwFlag,
                                            CXFA_Node* refNode) {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
+  if (!pScriptContext)
     return;
-  }
   XFA_RESOLVENODE_RS resoveNodeRS;
-  if (refNode == NULL) {
+  if (!refNode)
     refNode = this;
-  }
   pScriptContext->ResolveObjects(refNode, wsExpression.AsStringC(),
                                  resoveNodeRS, dwFlag);
   CXFA_ArrayNodeList* pNodeList = new CXFA_ArrayNodeList(m_pDocument);
   if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
     for (int32_t i = 0; i < resoveNodeRS.nodes.GetSize(); i++) {
       if (resoveNodeRS.nodes[i]->IsNode())
         pNodeList->Append(resoveNodeRS.nodes[i]->AsNode());
     }
   } else {
     CXFA_ValueArray valueArray(pScriptContext->GetRuntime());
     if (resoveNodeRS.GetAttributeResult(valueArray) > 0) {
       CXFA_ObjArray objectArray;
       valueArray.GetAttributeObject(objectArray);
       for (int32_t i = 0; i < objectArray.GetSize(); i++) {
         if (objectArray[i]->IsNode())
           pNodeList->Append(objectArray[i]->AsNode());
       }
     }
   }
   FXJSE_Value_SetObject(pValue, (CXFA_Object*)pNodeList,
                         pScriptContext->GetJseNormalClass());
 }
+
 void CXFA_Node::Script_TreeClass_All(CFXJSE_Value* pValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
     CFX_WideString wsName;
     GetAttribute(XFA_ATTRIBUTE_Name, wsName);
     CFX_WideString wsExpression = wsName + FX_WSTRC(L"[*]");
     Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag);
   }
 }
+
 void CXFA_Node::Script_TreeClass_Nodes(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
-  if (!pScriptContext) {
+  if (!pScriptContext)
     return;
-  }
   if (bSetting) {
     IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
     ASSERT(pAppProvider);
     CFX_WideString wsMessage;
     pAppProvider->LoadString(XFA_IDS_Unable_TO_SET, wsMessage);
     FXJSE_ThrowMessage(
         "",
         FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
   } else {
     CXFA_AttachNodeList* pNodeList = new CXFA_AttachNodeList(m_pDocument, this);
     FXJSE_Value_SetObject(pValue, (CXFA_Object*)pNodeList,
                           pScriptContext->GetJseNormalClass());
   }
 }
+
 void CXFA_Node::Script_TreeClass_ClassAll(CFXJSE_Value* pValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
     CFX_WideStringC wsName;
     GetClassName(wsName);
     CFX_WideString wsExpression = FX_WSTRC(L"#") + wsName + FX_WSTRC(L"[*]");
     Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag);
   }
 }
+
 void CXFA_Node::Script_TreeClass_Parent(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
     if (pParent) {
       FXJSE_Value_Set(
           pValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(pParent));
     } else {
       FXJSE_Value_SetNull(pValue);
     }
   }
 }
+
 void CXFA_Node::Script_TreeClass_Index(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
+  if (bSetting)
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
+  else
     FXJSE_Value_SetInteger(pValue, GetNodeSameNameIndex());
-  }
 }
+
 void CXFA_Node::Script_TreeClass_ClassIndex(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
+  if (bSetting)
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
+  else
     FXJSE_Value_SetInteger(pValue, GetNodeSameClassIndex());
-  }
 }
+
 void CXFA_Node::Script_TreeClass_SomExpression(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsSOMExpression;
     GetSOMExpression(wsSOMExpression);
     FXJSE_Value_SetUTF8String(pValue,
                               FX_UTF8Encode(wsSOMExpression).AsStringC());
   }
 }
+
 void CXFA_Node::Script_NodeClass_ApplyXSL(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"applyXSL");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   // TODO(weili): check whether we need to implement this, pdfium:501.
   // For now, just put the variables here to avoid unused variable warning.
   (void)wsExpression;
 }
 
 void CXFA_Node::Script_NodeClass_AssignNode(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"assignNode");
     return;
   }
   CFX_WideString wsExpression;
   CFX_WideString wsValue;
   int32_t iAction = 0;
-  if (iLength >= 1) {
-    wsExpression =
-        CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
-  }
+  wsExpression =
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   if (iLength >= 2) {
     wsValue =
         CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC());
   }
   if (iLength >= 3)
     iAction = pArguments->GetInt32(2);
   // TODO(weili): check whether we need to implement this, pdfium:501.
   // For now, just put the variables here to avoid unused variable warning.
   (void)wsExpression;
   (void)wsValue;
   (void)iAction;
 }
 
 void CXFA_Node::Script_NodeClass_Clone(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clone");
     return;
   }
-  FX_BOOL bClone = TRUE;
-  bClone = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
+  bool bClone = !!pArguments->GetInt32(0);
   CXFA_Node* pCloneNode = Clone(bClone);
   FXJSE_Value_Set(
       pArguments->GetReturnValue(),
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pCloneNode));
 }
+
 void CXFA_Node::Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"getAttribute");
     return;
   }
   CFX_WideString wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFX_WideString wsValue;
   GetAttribute(wsExpression.AsStringC(), wsValue);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
-  if (pValue) {
+  if (pValue)
     FXJSE_Value_SetUTF8String(pValue, FX_UTF8Encode(wsValue).AsStringC());
-  }
 }
+
 void CXFA_Node::Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getElement");
     return;
   }
   CFX_WideString wsExpression;
   int32_t iValue = 0;
-  if (iLength >= 1) {
-    CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsStringC());
-  }
-  if (iLength >= 2) {
+  wsExpression =
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
+  if (iLength >= 2)
     iValue = pArguments->GetInt32(1);
-  }
   const XFA_ELEMENTINFO* pElementInfo =
       XFA_GetElementByName(wsExpression.AsStringC());
   CXFA_Node* pNode = GetProperty(iValue, pElementInfo->eName);
   FXJSE_Value_Set(pArguments->GetReturnValue(),
                   m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
 }
 
 void CXFA_Node::Script_NodeClass_IsPropertySpecified(
     CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"isPropertySpecified");
     return;
   }
   CFX_WideString wsExpression;
-  FX_BOOL bParent = TRUE;
+  bool bParent = true;
   int32_t iIndex = 0;
-  if (iLength >= 1) {
-    wsExpression =
-        CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
-  }
+  wsExpression =
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   if (iLength >= 2)
-    bParent = !!pArguments->GetInt32(1) ? TRUE : FALSE;
+    bParent = !!pArguments->GetInt32(1);
   if (iLength >= 3)
     iIndex = pArguments->GetInt32(2);
   FX_BOOL bHas = FALSE;
   const XFA_ATTRIBUTEINFO* pAttributeInfo =
       XFA_GetAttributeByName(wsExpression.AsStringC());
   CFX_WideString wsValue;
   if (pAttributeInfo)
     bHas = HasAttribute(pAttributeInfo->eName);
   if (!bHas) {
     const XFA_ELEMENTINFO* pElementInfo =
@@ skipping 11 matching lines @@
     FXJSE_Value_SetBoolean(pValue, bHas);
 }
 
 void CXFA_Node::Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"loadXML");
     return;
   }
   CFX_WideString wsExpression;
-  FX_BOOL bIgnoreRoot = TRUE;
-  FX_BOOL bOverwrite = 0;
-  if (iLength >= 1) {
-    CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsStringC());
-    if (wsExpression.IsEmpty()) {
-      return;
-    }
-  }
-  if (iLength >= 2) {
-    bIgnoreRoot = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
-  }
-  if (iLength >= 3) {
-    bOverwrite = pArguments->GetInt32(2) == 0 ? FALSE : TRUE;
-  }
-  IXFA_Parser* pParser = IXFA_Parser::Create(m_pDocument);
-  if (!pParser) {
+  bool bIgnoreRoot = true;
+  bool bOverwrite = 0;
+  wsExpression =
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
+  if (wsExpression.IsEmpty())
     return;
-  }
-  CFDE_XMLNode* pXMLNode = NULL;
-  int32_t iParserStatus = pParser->ParseXMLData(wsExpression, pXMLNode, NULL);
-  if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode) {
-    pParser->Release();
-    pParser = NULL;
+  if (iLength >= 2)
+    bIgnoreRoot = !!pArguments->GetInt32(1);
+  if (iLength >= 3)
+    bOverwrite = !!pArguments->GetInt32(2);
+  std::unique_ptr<IXFA_Parser, ReleaseDeleter<IXFA_Parser>> pParser(
+      IXFA_Parser::Create(m_pDocument));
+  if (!pParser)
     return;
-  }
+  CFDE_XMLNode* pXMLNode = nullptr;
+  int32_t iParserStatus =
+      pParser->ParseXMLData(wsExpression, pXMLNode, nullptr);
+  if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode)
+    return;
   if (bIgnoreRoot &&
       (pXMLNode->GetType() != FDE_XMLNODE_Element ||
        XFA_RecognizeRichText(static_cast<CFDE_XMLElement*>(pXMLNode)))) {
-    bIgnoreRoot = FALSE;
+    bIgnoreRoot = false;
   }
   CXFA_Node* pFakeRoot = Clone(FALSE);
   CFX_WideStringC wsContentType = GetCData(XFA_ATTRIBUTE_ContentType);
   if (!wsContentType.IsEmpty()) {
     pFakeRoot->SetCData(XFA_ATTRIBUTE_ContentType,
                         CFX_WideString(wsContentType));
   }
   CFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode();
   if (!pFakeXMLRoot) {
     CFDE_XMLNode* pThisXMLRoot = GetXMLMappingNode();
-    pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : NULL;
+    pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : nullptr;
   }
   if (!pFakeXMLRoot) {
     CFX_WideStringC wsClassName;
     GetClassName(wsClassName);
     pFakeXMLRoot = new CFDE_XMLElement(CFX_WideString(wsClassName));
   }
   if (bIgnoreRoot) {
     CFDE_XMLNode* pXMLChild = pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
     while (pXMLChild) {
       CFDE_XMLNode* pXMLSibling =
@@ skipping 27 matching lines @@
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         RemoveChild(pChild);
         pFakeRoot->InsertChild(pChild);
         pChild = pItem;
       }
       if (GetPacketID() == XFA_XDPPACKET_Form &&
           GetClassID() == XFA_ELEMENT_ExData) {
         CFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
         SetXMLMappingNode(pFakeXMLRoot);
         SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
-        if (pTempXMLNode &&
-            pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL) {
+        if (pTempXMLNode && !pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent)) {
           pFakeXMLRoot = pTempXMLNode;
         } else {
-          pFakeXMLRoot = NULL;
+          pFakeXMLRoot = nullptr;
         }
       }
       MoveBufferMapData(pFakeRoot, this, XFA_CalcData, TRUE);
     } else {
       CXFA_Node* pChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
       while (pChild) {
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         pFakeRoot->RemoveChild(pChild);
         InsertChild(pChild);
         pChild->SetFlag(XFA_NODEFLAG_Initialized, true);
         pChild = pItem;
       }
     }
     if (pFakeXMLRoot) {
       pFakeRoot->SetXMLMappingNode(pFakeXMLRoot);
       pFakeRoot->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
     }
     pFakeRoot->SetFlag(XFA_NODEFLAG_HasRemoved, false);
   } else {
     if (pFakeXMLRoot) {
       pFakeXMLRoot->Release();
-      pFakeXMLRoot = NULL;
+      pFakeXMLRoot = nullptr;
     }
   }
-  pParser->Release();
-  pParser = NULL;
 }
+
 void CXFA_Node::Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments) {
+  // TODO(weili): Check whether we need to implement this, pdfium:501.
 }
 
 void CXFA_Node::Script_NodeClass_SaveXML(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 0 || iLength > 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"saveXML");
     return;
   }
-  FX_BOOL bPrettyMode = FALSE;
+  bool bPrettyMode = false;
   if (iLength == 1) {
     if (pArguments->GetUTF8String(0) != "pretty") {
       ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
       return;
     }
-    bPrettyMode = TRUE;
+    bPrettyMode = true;
   }
   CFX_ByteStringC bsXMLHeader = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
   if (GetPacketID() == XFA_XDPPACKET_Form ||
       GetPacketID() == XFA_XDPPACKET_Datasets) {
     CFDE_XMLNode* pElement = nullptr;
     if (GetPacketID() == XFA_XDPPACKET_Datasets) {
       pElement = GetXMLMappingNode();
       if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
         FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
         return;
       }
       XFA_DataExporter_DealWithDataGroupNode(this);
     }
-    std::unique_ptr<IFX_MemoryStream> pMemoryStream(
-        FX_CreateMemoryStream(TRUE));
-    std::unique_ptr<IFX_Stream> pStream(IFX_Stream::CreateStream(
-        (IFX_FileWrite*)pMemoryStream.get(),
-        FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append));
+    std::unique_ptr<IFX_MemoryStream, ReleaseDeleter<IFX_MemoryStream>>
+        pMemoryStream(FX_CreateMemoryStream(TRUE));
+    std::unique_ptr<IFX_Stream, ReleaseDeleter<IFX_Stream>> pStream(
+        IFX_Stream::CreateStream(
+            static_cast<IFX_FileWrite*>(pMemoryStream.get()),
+            FX_STREAMACCESS_Text | FX_STREAMACCESS_Write |
+                FX_STREAMACCESS_Append));
     if (!pStream) {
       FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
       return;
     }
     pStream->SetCodePage(FX_CODEPAGE_UTF8);
     pStream->WriteData(bsXMLHeader.raw_str(), bsXMLHeader.GetLength());
     if (GetPacketID() == XFA_XDPPACKET_Form)
-      XFA_DataExporter_RegenerateFormFile(this, pStream.get(), NULL, TRUE);
+      XFA_DataExporter_RegenerateFormFile(this, pStream.get(), nullptr, TRUE);
     else
       pElement->SaveXMLNode(pStream.get());
     // TODO(weili): Check whether we need to save pretty print XML, pdfium:501.
     // For now, just put it here to avoid unused variable warning.
     (void)bPrettyMode;
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
         CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
     return;
   }
   FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), "");
 }
 
 void CXFA_Node::Script_NodeClass_SetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"setAttribute");
     return;
   }
   CFX_WideString wsAttributeValue =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFX_WideString wsAttribute =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC());
-  SetAttribute(wsAttribute.AsStringC(), wsAttributeValue.AsStringC(), TRUE);
+  SetAttribute(wsAttribute.AsStringC(), wsAttributeValue.AsStringC(), true);
 }
 
 void CXFA_Node::Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1 && iLength != 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setElement");
     return;
   }
   CXFA_Node* pNode = nullptr;
   CFX_WideString wsName;
-  if (iLength >= 1)
-    pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
-  if (iLength >= 2) {
+  pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
+  if (iLength == 2)
     wsName = CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC());
-  }
   // TODO(weili): check whether we need to implement this, pdfium:501.
   // For now, just put the variables here to avoid unused variable warning.
   (void)pNode;
   (void)wsName;
 }
 
 void CXFA_Node::Script_NodeClass_Ns(CFXJSE_Value* pValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsNameSpace;
     TryNamespace(wsNameSpace);
     FXJSE_Value_SetUTF8String(pValue, FX_UTF8Encode(wsNameSpace).AsStringC());
   }
 }
+
 void CXFA_Node::Script_NodeClass_Model(CFXJSE_Value* pValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     FXJSE_Value_Set(pValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(
                                 GetModelNode()));
   }
 }
+
 void CXFA_Node::Script_NodeClass_IsContainer(CFXJSE_Value* pValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
-  if (bSetting) {
+  if (bSetting)
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
-  } else {
+  else
     FXJSE_Value_SetBoolean(pValue, IsContainerNode());
-  }
 }
+
 void CXFA_Node::Script_NodeClass_IsNull(CFXJSE_Value* pValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     if (GetClassID() == XFA_ELEMENT_Subform) {
       FXJSE_Value_SetBoolean(pValue, FALSE);
       return;
     }
     CFX_WideString strValue;
     FXJSE_Value_SetBoolean(pValue, !TryContent(strValue) || strValue.IsEmpty());
   }
 }
+
 void CXFA_Node::Script_NodeClass_OneOfChild(CFXJSE_Value* pValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_NodeArray properts;
     int32_t iSize = GetNodeList(properts, XFA_NODEFILTER_OneOfProperty);
     if (iSize > 0) {
       FXJSE_Value_Set(
           pValue,
           m_pDocument->GetScriptContext()->GetJSValueFromMap(properts[0]));
     }
   }
 }
+
 void CXFA_Node::Script_ContainerClass_GetDelta(CFXJSE_Arguments* pArguments) {}
 void CXFA_Node::Script_ContainerClass_GetDeltas(CFXJSE_Arguments* pArguments) {
   CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument);
   FXJSE_Value_SetObject(pArguments->GetReturnValue(), (CXFA_Object*)pFormNodes,
                         m_pDocument->GetScriptContext()->GetJseNormalClass());
 }
 void CXFA_Node::Script_ModelClass_ClearErrorList(CFXJSE_Arguments* pArguments) {
 }
 void CXFA_Node::Script_ModelClass_CreateNode(CFXJSE_Arguments* pArguments) {
   Script_Template_CreateNode(pArguments);
@@ skipping 229 matching lines @@
       CXFA_Node* pProtoRoot =
           pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Subform)
               ->GetFirstChildByClass(XFA_ELEMENT_Proto);
       if (!wsUseVal.IsEmpty()) {
         if (wsUseVal[0] == '#') {
           wsID = CFX_WideString(wsUseVal.c_str() + 1, wsUseVal.GetLength() - 1);
         } else {
           wsSOM = wsUseVal;
         }
       }
-      CXFA_Node* pProtoNode = NULL;
+      CXFA_Node* pProtoNode = nullptr;
       if (!wsSOM.IsEmpty()) {
         uint32_t dwFlag = XFA_RESOLVENODE_Children |
                           XFA_RESOLVENODE_Attributes |
                           XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                           XFA_RESOLVENODE_Siblings;
         XFA_RESOLVENODE_RS resoveNodeRS;
         int32_t iRet = m_pDocument->GetScriptContext()->ResolveObjects(
             pProtoRoot, wsSOM.AsStringC(), resoveNodeRS, dwFlag);
         if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) {
           pProtoNode = resoveNodeRS.nodes[0]->AsNode();
@@ skipping 157 matching lines @@
     Script_Boolean_Value(pValue, bSetting, eAttribute);
     return;
   }
   if (bSetting) {
     CFX_ByteString newValue;
     if (!(FXJSE_Value_IsNull(pValue) || FXJSE_Value_IsUndefined(pValue))) {
       FXJSE_Value_ToUTF8String(pValue, newValue);
     }
     CFX_WideString wsNewValue = CFX_WideString::FromUTF8(newValue.AsStringC());
     CFX_WideString wsFormatValue(wsNewValue);
-    CXFA_WidgetData* pContainerWidgetData = NULL;
+    CXFA_WidgetData* pContainerWidgetData = nullptr;
     if (GetPacketID() == XFA_XDPPACKET_Datasets) {
       CXFA_NodeArray formNodes;
       GetBindItems(formNodes);
       CFX_WideString wsPicture;
       for (int32_t i = 0; i < formNodes.GetSize(); i++) {
         CXFA_Node* pFormNode = formNodes.GetAt(i);
         if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
           continue;
         }
         pContainerWidgetData = pFormNode->GetContainerWidgetData();
         if (pContainerWidgetData) {
           pContainerWidgetData->GetPictureContent(wsPicture,
                                                   XFA_VALUEPICTURE_DataBind);
         }
         if (!wsPicture.IsEmpty()) {
           break;
         }
-        pContainerWidgetData = NULL;
+        pContainerWidgetData = nullptr;
       }
     } else if (GetPacketID() == XFA_XDPPACKET_Form) {
       pContainerWidgetData = GetContainerWidgetData();
     }
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue);
     }
     SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
@@ skipping 810 matching lines @@
     }
     if ((eCurType != XFA_ELEMENT_Subform) &&
         (eCurType != XFA_ELEMENT_SubformSet)) {
       continue;
     }
     if (iCount == 0) {
       CFX_WideStringC wsName = pNode->GetCData(XFA_ATTRIBUTE_Name);
       CFX_WideStringC wsInstName = pInstMgrNode->GetCData(XFA_ATTRIBUTE_Name);
       if (wsInstName.GetLength() < 1 || wsInstName.GetAt(0) != '_' ||
           wsInstName.Mid(1) != wsName) {
-        return NULL;
+        return nullptr;
       }
       dwNameHash = pNode->GetNameHash();
     }
     if (dwNameHash != pNode->GetNameHash()) {
       break;
     }
     iCount++;
     if (iCount > iIndex) {
       return pNode;
     }
   }
-  return NULL;
+  return nullptr;
 }
 void CXFA_Node::Script_Som_InstanceIndex(CFXJSE_Value* pValue,
                                          FX_BOOL bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     int32_t iTo = FXJSE_Value_ToInteger(pValue);
     int32_t iFrom = Subform_and_SubformSet_InstanceIndex();
-    CXFA_Node* pManagerNode = NULL;
+    CXFA_Node* pManagerNode = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       if (pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
         pManagerNode = pNode;
         break;
       }
     }
     if (pManagerNode) {
       pManagerNode->InstanceManager_MoveInstance(iTo, iFrom);
       CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
@@ skipping 13 matching lines @@
     }
   } else {
     FXJSE_Value_SetInteger(pValue, Subform_and_SubformSet_InstanceIndex());
   }
 }
 void CXFA_Node::Script_Subform_InstanceManager(CFXJSE_Value* pValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
-    CXFA_Node* pInstanceMgr = NULL;
+    CXFA_Node* pInstanceMgr = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       if (pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
         CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' &&
             wsInstMgrName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
         }
         break;
       }
@@ skipping 478 matching lines @@
     CXFA_Node* pDataNode = pFormNode->GetBindData();
     if (!pDataNode) {
       continue;
     }
     if (pDataNode->RemoveBindItem(pFormNode) == 0) {
       if (CXFA_Node* pDataParent =
               pDataNode->GetNodeItem(XFA_NODEITEM_Parent)) {
         pDataParent->RemoveChild(pDataNode);
       }
     }
-    pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
+    pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
   }
 }
 static CXFA_Node* XFA_ScriptInstanceManager_CreateInstance(
     CXFA_Node* pInstMgrNode,
     FX_BOOL bDataMerge) {
   CXFA_Document* pDocument = pInstMgrNode->GetDocument();
   CXFA_Node* pTemplateNode = pInstMgrNode->GetTemplateNode();
   CXFA_Node* pFormParent = pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent);
-  CXFA_Node* pDataScope = NULL;
+  CXFA_Node* pDataScope = nullptr;
   for (CXFA_Node* pRootBoundNode = pFormParent;
        pRootBoundNode &&
        pRootBoundNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode;
        pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
     pDataScope = pRootBoundNode->GetBindData();
     if (pDataScope) {
       break;
     }
   }
   if (!pDataScope) {
@@ skipping 636 matching lines @@
                             XFA_KEYTYPE_Element);
 }
 FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   return HasMapModuleKey(pKey, bCanInherit);
 }
 FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr,
                                 const CFX_WideStringC& wsValue,
                                 bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
-  if (pAttr == NULL) {
+  if (!pAttr)
     return FALSE;
-  }
+
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
         XFA_GetNotsureAttribute(GetClassID(), pAttr->eName);
     eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
   }
   switch (eType) {
     case XFA_ATTRIBUTETYPE_Enum: {
       const XFA_ATTRIBUTEENUMINFO* pEnum = XFA_GetAttributeEnumByName(wsValue);
       return SetEnum(pAttr->eName,
@@ skipping 14 matching lines @@
       return SetMeasure(pAttr->eName, CXFA_Measurement(wsValue), bNotify);
     default:
       break;
   }
   return FALSE;
 }
 FX_BOOL CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr,
                                 CFX_WideString& wsValue,
                                 FX_BOOL bUseDefault) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
-  if (pAttr == NULL) {
+  if (!pAttr) {
     return FALSE;
   }
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
         XFA_GetNotsureAttribute(GetClassID(), pAttr->eName);
     eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
   }
   switch (eType) {
     case XFA_ATTRIBUTETYPE_Enum: {
@@ skipping 67 matching lines @@
   return TRUE;
 }
 FX_BOOL CXFA_Node::RemoveAttribute(const CFX_WideStringC& wsAttr) {
   void* pKey = XFA_GetMapKey_Custom(wsAttr);
   RemoveMapModuleKey(pKey);
   return TRUE;
 }
 FX_BOOL CXFA_Node::TryBoolean(XFA_ATTRIBUTE eAttr,
                               FX_BOOL& bValue,
                               FX_BOOL bUseDefault) {
-  void* pValue = NULL;
-  if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, bUseDefault, pValue)) {
+  void* pValue = nullptr;
+  if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, bUseDefault, pValue))
     return FALSE;
-  }
   bValue = (FX_BOOL)(uintptr_t)pValue;
   return TRUE;
 }
 FX_BOOL CXFA_Node::TryInteger(XFA_ATTRIBUTE eAttr,
                               int32_t& iValue,
                               FX_BOOL bUseDefault) {
-  void* pValue = NULL;
-  if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, bUseDefault, pValue)) {
+  void* pValue = nullptr;
+  if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, bUseDefault, pValue))
     return FALSE;
-  }
   iValue = (int32_t)(uintptr_t)pValue;
   return TRUE;
 }
 FX_BOOL CXFA_Node::TryEnum(XFA_ATTRIBUTE eAttr,
                            XFA_ATTRIBUTEENUM& eValue,
                            FX_BOOL bUseDefault) {
-  void* pValue = NULL;
-  if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue)) {
+  void* pValue = nullptr;
+  if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue))
     return FALSE;
-  }
   eValue = (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
   return TRUE;
 }
 
 FX_BOOL CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr,
                               CXFA_Measurement mValue,
                               bool bNotify) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   OnChanging(eAttr, bNotify);
   SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement));
@@ skipping 160 matching lines @@
   } else {
     CFX_WideStringC wsValueC;
     if (GetMapModuleString(pKey, wsValueC)) {
       wsValue = wsValueC;
       return TRUE;
     }
   }
   if (!bUseDefault) {
     return FALSE;
   }
-  void* pValue = NULL;
+  void* pValue = nullptr;
   if (XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr,
                                    XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
     wsValue = (const FX_WCHAR*)pValue;
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
                             CFX_WideStringC& wsValue,
                             FX_BOOL bUseDefault,
                             FX_BOOL bProto) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
     if (pStr) {
       wsValue = pStr->AsStringC();
       return TRUE;
     }
   } else {
     if (GetMapModuleString(pKey, wsValue)) {
       return TRUE;
     }
   }
   if (!bUseDefault) {
     return FALSE;
   }
-  void* pValue = NULL;
+  void* pValue = nullptr;
   if (XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr,
                                    XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
     wsValue = (CFX_WideStringC)(const FX_WCHAR*)pValue;
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr,
                              void* pData,
                              XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   return SetUserData(pKey, pData, pCallbackInfo);
 }
 FX_BOOL CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, void*& pData) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   pData = GetUserData(pKey);
-  return pData != NULL;
+  return pData != nullptr;
 }
 FX_BOOL CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr,
                             XFA_ATTRIBUTETYPE eType,
                             void* pValue,
                             bool bNotify) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   OnChanging(eAttr, bNotify);
   SetMapModuleValue(pKey, pValue);
   OnChanged(eAttr, bNotify, FALSE);
   if (IsNeedSavingXMLNode()) {
@@ skipping 32 matching lines @@
     return TRUE;
   }
   if (!bUseDefault) {
     return FALSE;
   }
   return XFA_GetAttributeDefaultValue(pValue, GetClassID(), eAttr, eType,
                                       m_ePacket);
 }
 static void XFA_DefaultFreeData(void* pData) {}
 static XFA_MAPDATABLOCKCALLBACKINFO gs_XFADefaultFreeData = {
-    XFA_DefaultFreeData, NULL};
+    XFA_DefaultFreeData, nullptr};
 FX_BOOL CXFA_Node::SetUserData(void* pKey,
                                void* pData,
                                XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   SetMapModuleBuffer(pKey, &pData, sizeof(void*),
                      pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData);
   return TRUE;
 }
 FX_BOOL CXFA_Node::TryUserData(void* pKey, void*& pData, FX_BOOL bProtoAlso) {
   int32_t iBytes = 0;
   if (!GetMapModuleBuffer(pKey, pData, iBytes, bProtoAlso)) {
     return FALSE;
   }
   return iBytes == sizeof(void*) && FXSYS_memcpy(&pData, pData, iBytes);
 }
 FX_BOOL CXFA_Node::SetScriptContent(const CFX_WideString& wsContent,
                                     const CFX_WideString& wsXMLValue,
                                     bool bNotify,
                                     FX_BOOL bScriptModify,
                                     FX_BOOL bSyncData) {
-  CXFA_Node* pNode = NULL;
-  CXFA_Node* pBindNode = NULL;
+  CXFA_Node* pNode = nullptr;
+  CXFA_Node* pBindNode = nullptr;
   switch (GetObjectType()) {
     case XFA_OBJECTTYPE_ContainerNode: {
       if (XFA_FieldIsMultiListBox(this)) {
         CXFA_Node* pValue = GetProperty(0, XFA_ELEMENT_Value);
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         ASSERT(pChildValue);
         pChildValue->SetCData(XFA_ATTRIBUTE_ContentType, L"text/xml");
         pChildValue->SetScriptContent(wsContent, wsContent, bNotify,
                                       bScriptModify, FALSE);
         CXFA_Node* pBind = GetBindData();
@@ skipping 22 matching lines @@
             while (CXFA_Node* pChildNode =
                        pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) {
               pBind->RemoveChild(pChildNode);
             }
           } else {
             CXFA_NodeArray valueNodes;
             int32_t iDatas = pBind->GetNodeList(
                 valueNodes, XFA_NODEFILTER_Children, XFA_ELEMENT_DataValue);
             if (iDatas < iSize) {
               int32_t iAddNodes = iSize - iDatas;
-              CXFA_Node* pValueNodes = NULL;
+              CXFA_Node* pValueNodes = nullptr;
               while (iAddNodes-- > 0) {
                 pValueNodes =
                     pBind->CreateSamePacketNode(XFA_ELEMENT_DataValue);
                 pValueNodes->SetCData(XFA_ATTRIBUTE_Name, L"value");
                 pValueNodes->CreateXMLMappingNode();
                 pBind->InsertChild(pValueNodes);
               }
-              pValueNodes = NULL;
+              pValueNodes = nullptr;
             } else if (iDatas > iSize) {
               int32_t iDelNodes = iDatas - iSize;
               while (iDelNodes-- > 0) {
                 pBind->RemoveChild(pBind->GetNodeItem(XFA_NODEITEM_FirstChild));
               }
             }
             int32_t i = 0;
             for (CXFA_Node* pValueNode =
                      pBind->GetNodeItem(XFA_NODEITEM_FirstChild);
                  pValueNode; pValueNode = pValueNode->GetNodeItem(
@@ skipping 31 matching lines @@
         CXFA_NodeArray nodeArray;
         pBindNode->GetBindItems(nodeArray);
         for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
           CXFA_Node* pNode = nodeArray[i];
           if (pNode == this) {
             continue;
           }
           pNode->SetScriptContent(wsContent, wsContent, bNotify, true, FALSE);
         }
       }
-      pBindNode = NULL;
+      pBindNode = nullptr;
       break;
     }
     case XFA_OBJECTTYPE_ContentNode: {
       CFX_WideString wsContentType;
       if (GetClassID() == XFA_ELEMENT_ExData) {
         GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
         if (wsContentType == FX_WSTRC(L"text/html")) {
           wsContentType = FX_WSTRC(L"");
           SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType.AsStringC());
         }
@@ skipping 64 matching lines @@
 CFX_WideString CXFA_Node::GetScriptContent(FX_BOOL bScriptModify) {
   CFX_WideString wsContent;
   return TryContent(wsContent, bScriptModify) ? wsContent : CFX_WideString();
 }
 CFX_WideString CXFA_Node::GetContent() {
   return GetScriptContent();
 }
 FX_BOOL CXFA_Node::TryContent(CFX_WideString& wsContent,
                               FX_BOOL bScriptModify,
                               FX_BOOL bProto) {
-  CXFA_Node* pNode = NULL;
+  CXFA_Node* pNode = nullptr;
   switch (GetObjectType()) {
     case XFA_OBJECTTYPE_ContainerNode:
       if (GetClassID() == XFA_ELEMENT_ExclGroup) {
         pNode = this;
       } else {
         CXFA_Node* pValue = GetChild(0, XFA_ELEMENT_Value);
         if (!pValue) {
           return FALSE;
         }
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
@@ skipping 100 matching lines @@
     return pModelNode->TryNamespace(wsNamespace);
   }
 }
 CXFA_Node* CXFA_Node::GetProperty(int32_t index,
                                   XFA_ELEMENT eProperty,
                                   FX_BOOL bCreateProperty) {
   XFA_ELEMENT eElement = GetClassID();
   uint32_t dwPacket = GetPacketID();
   const XFA_PROPERTY* pProperty =
       XFA_GetPropertyOfElement(eElement, eProperty, dwPacket);
-  if (pProperty == NULL || index >= pProperty->uOccur) {
-    return NULL;
-  }
+  if (!pProperty || index >= pProperty->uOccur)
+    return nullptr;
+
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eProperty) {
       iCount++;
       if (iCount > index) {
         return pNode;
       }
     }
   }
-  if (!bCreateProperty) {
-    return NULL;
-  }
+  if (!bCreateProperty)
+    return nullptr;
+
   if (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf) {
     pNode = m_pChild;
     for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       const XFA_PROPERTY* pExistProperty =
           XFA_GetPropertyOfElement(eElement, pNode->GetClassID(), dwPacket);
-      if (pExistProperty && (pExistProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
-        return NULL;
-      }
+      if (pExistProperty && (pExistProperty->uFlags & XFA_PROPERTYFLAG_OneOf))
+        return nullptr;
     }
   }
   CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
   const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(dwPacket);
   CXFA_Node* pNewNode = nullptr;
   for (; iCount <= index; iCount++) {
     pNewNode = pFactory->CreateNode(pPacket, eProperty);
-    if (!pNewNode) {
-      return NULL;
-    }
+    if (!pNewNode)
+      return nullptr;
     InsertChild(pNewNode, nullptr);
     pNewNode->SetFlag(XFA_NODEFLAG_Initialized, true);
   }
   return pNewNode;
 }
 int32_t CXFA_Node::CountChildren(XFA_ELEMENT eElement, FX_BOOL bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eElement || eElement == XFA_ELEMENT_UNKNOWN) {
@@ skipping 23 matching lines @@
         if (pProperty) {
           continue;
         }
       }
       iCount++;
       if (iCount > index) {
         return pNode;
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 int32_t CXFA_Node::InsertChild(int32_t index, CXFA_Node* pNode) {
   ASSERT(!pNode->m_pNext);
   pNode->m_pParent = this;
   FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode);
   ASSERT(ret);
   (void)ret;  // Avoid unused variable warning.
 
-  if (m_pChild == NULL || index == 0) {
+  if (!m_pChild || index == 0) {
     if (index > 0) {
       return -1;
     }
     pNode->m_pNext = m_pChild;
     m_pChild = pNode;
     index = 0;
   } else if (index < 0) {
     m_pLastChild->m_pNext = pNode;
   } else {
     CXFA_Node* pPrev = m_pChild;
     int32_t iCount = 0;
     while (++iCount != index && pPrev->m_pNext) {
       pPrev = pPrev->m_pNext;
     }
     if (index > 0 && index != iCount) {
       return -1;
     }
     pNode->m_pNext = pPrev->m_pNext;
     pPrev->m_pNext = pNode;
     index = iCount;
   }
-  if (pNode->m_pNext == NULL) {
+  if (!pNode->m_pNext) {
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
-  ASSERT(m_pLastChild->m_pNext == NULL);
+  ASSERT(!m_pLastChild->m_pNext);
   pNode->ClearFlag(XFA_NODEFLAG_HasRemoved);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (pNotify)
     pNotify->OnChildAdded(this);
 
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
-    ASSERT(pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL);
+    ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index);
     pNode->ClearFlag(XFA_NODEFLAG_OwnXMLNode);
   }
   return index;
 }
 
 FX_BOOL CXFA_Node::InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode) {
   if (!pNode || pNode->m_pParent ||
       (pBeforeNode && pBeforeNode->m_pParent != this)) {
     ASSERT(false);
     return FALSE;
   }
   FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode);
   ASSERT(ret);
   (void)ret;  // Avoid unused variable warning.
 
   int32_t nIndex = -1;
   pNode->m_pParent = this;
-  if (m_pChild == NULL || pBeforeNode == m_pChild) {
+  if (!m_pChild || pBeforeNode == m_pChild) {
     pNode->m_pNext = m_pChild;
     m_pChild = pNode;
     nIndex = 0;
   } else if (!pBeforeNode) {
     pNode->m_pNext = m_pLastChild->m_pNext;
     m_pLastChild->m_pNext = pNode;
   } else {
     nIndex = 1;
     CXFA_Node* pPrev = m_pChild;
     while (pPrev->m_pNext != pBeforeNode) {
       pPrev = pPrev->m_pNext;
       nIndex++;
     }
     pNode->m_pNext = pPrev->m_pNext;
     pPrev->m_pNext = pNode;
   }
-  if (pNode->m_pNext == NULL) {
+  if (!pNode->m_pNext) {
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
-  ASSERT(m_pLastChild->m_pNext == NULL);
+  ASSERT(!m_pLastChild->m_pNext);
   pNode->ClearFlag(XFA_NODEFLAG_HasRemoved);
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (pNotify)
     pNotify->OnChildAdded(this);
 
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
-    ASSERT(pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL);
+    ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex);
     pNode->ClearFlag(XFA_NODEFLAG_OwnXMLNode);
   }
   return TRUE;
 }
 CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling() {
   if (!m_pParent) {
-    return NULL;
+    return nullptr;
   }
   for (CXFA_Node* pSibling = m_pParent->m_pChild; pSibling;
        pSibling = pSibling->m_pNext) {
     if (pSibling->m_pNext == this) {
       return pSibling;
     }
   }
-  return NULL;
+  return nullptr;
 }
 FX_BOOL CXFA_Node::RemoveChild(CXFA_Node* pNode, bool bNotify) {
-  if (pNode == NULL || pNode->m_pParent != this) {
+  if (!pNode || pNode->m_pParent != this) {
     ASSERT(FALSE);
     return FALSE;
   }
   if (m_pChild == pNode) {
     m_pChild = pNode->m_pNext;
     if (m_pLastChild == pNode) {
       m_pLastChild = pNode->m_pNext;
     }
-    pNode->m_pNext = NULL;
-    pNode->m_pParent = NULL;
+    pNode->m_pNext = nullptr;
+    pNode->m_pParent = nullptr;
   } else {
     CXFA_Node* pPrev = pNode->Deprecated_GetPrevSibling();
     pPrev->m_pNext = pNode->m_pNext;
     if (m_pLastChild == pNode) {
       m_pLastChild = pNode->m_pNext ? pNode->m_pNext : pPrev;
     }
-    pNode->m_pNext = NULL;
-    pNode->m_pParent = NULL;
+    pNode->m_pNext = nullptr;
+    pNode->m_pParent = nullptr;
   }
-  ASSERT(m_pLastChild == NULL || m_pLastChild->m_pNext == NULL);
+  ASSERT(!m_pLastChild || !m_pLastChild->m_pNext);
   OnRemoved(bNotify);
   pNode->SetFlag(XFA_NODEFLAG_HasRemoved, true);
   m_pDocument->AddPurgeNode(pNode);
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     if (pNode->IsAttributeInXML()) {
       ASSERT(pNode->m_pXMLNode == m_pXMLNode &&
              m_pXMLNode->GetType() == FDE_XMLNODE_Element);
       if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) {
         CFDE_XMLElement* pXMLElement =
             static_cast<CFDE_XMLElement*>(pNode->m_pXMLNode);
@@ skipping 20 matching lines @@
 CXFA_Node* CXFA_Node::GetFirstChildByName(const CFX_WideStringC& wsName) const {
   return GetFirstChildByName(FX_HashCode_GetW(wsName, false));
 }
 CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
-  return NULL;
+  return nullptr;
 }
 CXFA_Node* CXFA_Node::GetFirstChildByClass(XFA_ELEMENT eElement) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eElement) {
       return pNode;
     }
   }
-  return NULL;
+  return nullptr;
 }
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
-  return NULL;
+  return nullptr;
 }
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(
     const CFX_WideStringC& wsNodeName) const {
   return GetNextSameNameSibling(FX_HashCode_GetW(wsNodeName, false));
 }
 CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_ELEMENT eElement) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eElement) {
       return pNode;
     }
   }
-  return NULL;
+  return nullptr;
 }
 int32_t CXFA_Node::GetNodeSameNameIndex() const {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return -1;
   }
   return pScriptContext->GetIndexByName(const_cast<CXFA_Node*>(this));
 }
 int32_t CXFA_Node::GetNodeSameClassIndex() const {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return -1;
   }
   return pScriptContext->GetIndexByClassName(const_cast<CXFA_Node*>(this));
 }
 void CXFA_Node::GetSOMExpression(CFX_WideString& wsSOMExpression) {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   pScriptContext->GetSomExpression(this, wsSOMExpression);
 }
 CXFA_Node* CXFA_Node::GetInstanceMgrOfSubform() {
-  CXFA_Node* pInstanceMgr = NULL;
+  CXFA_Node* pInstanceMgr = nullptr;
   if (m_ePacket == XFA_XDPPACKET_Form) {
     CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
     if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_Area) {
       return pInstanceMgr;
     }
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       XFA_ELEMENT eType = pNode->GetClassID();
       if ((eType == XFA_ELEMENT_Subform || eType == XFA_ELEMENT_SubformSet) &&
           pNode->m_dwNameHash != m_dwNameHash) {
@@ skipping 175 matching lines @@
 
 FX_BOOL CXFA_Node::GetMapModuleValue(void* pKey, void*& pValue) {
   CXFA_Node* pNode = this;
   while (pNode) {
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule && pModule->m_ValueMap.Lookup(pKey, pValue)) {
       return TRUE;
     }
     pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets
                 ? pNode->GetTemplateNode()
-                : NULL;
+                : nullptr;
   }
   return FALSE;
 }
 void CXFA_Node::SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue) {
   SetMapModuleBuffer(pKey, (void*)wsValue.c_str(),
                      wsValue.GetLength() * sizeof(FX_WCHAR));
 }
 FX_BOOL CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) {
   void* pValue;
   int32_t iBytes;
   if (!GetMapModuleBuffer(pKey, pValue, iBytes)) {
     return FALSE;
   }
   wsValue = CFX_WideStringC((const FX_WCHAR*)pValue, iBytes / sizeof(FX_WCHAR));
   return TRUE;
 }
 void CXFA_Node::SetMapModuleBuffer(
     void* pKey,
     void* pValue,
     int32_t iBytes,
     XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   XFA_MAPMODULEDATA* pModule = CreateMapModuleData();
   XFA_MAPDATABLOCK*& pBuffer = pModule->m_BufferMap[pKey];
-  if (pBuffer == NULL) {
+  if (!pBuffer) {
     pBuffer =
         (XFA_MAPDATABLOCK*)FX_Alloc(uint8_t, sizeof(XFA_MAPDATABLOCK) + iBytes);
   } else if (pBuffer->iBytes != iBytes) {
     if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
       pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
     }
     pBuffer = (XFA_MAPDATABLOCK*)FX_Realloc(uint8_t, pBuffer,
                                             sizeof(XFA_MAPDATABLOCK) + iBytes);
   } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
     pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
   }
-  if (pBuffer == NULL) {
+  if (!pBuffer)
     return;
-  }
+
   pBuffer->pCallbackInfo = pCallbackInfo;
   pBuffer->iBytes = iBytes;
   FXSYS_memcpy(pBuffer->GetData(), pValue, iBytes);
 }
 FX_BOOL CXFA_Node::GetMapModuleBuffer(void* pKey,
                                       void*& pValue,
                                       int32_t& iBytes,
                                       FX_BOOL bProtoAlso) const {
-  XFA_MAPDATABLOCK* pBuffer = NULL;
+  XFA_MAPDATABLOCK* pBuffer = nullptr;
   const CXFA_Node* pNode = this;
   while (pNode) {
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule && pModule->m_BufferMap.Lookup(pKey, pBuffer)) {
       break;
     }
     pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
                 ? pNode->GetTemplateNode()
-                : NULL;
+                : nullptr;
   }
-  if (pBuffer == NULL) {
+  if (!pBuffer) {
     return FALSE;
   }
   pValue = pBuffer->GetData();
   iBytes = pBuffer->iBytes;
   return TRUE;
 }
 FX_BOOL CXFA_Node::HasMapModuleKey(void* pKey, FX_BOOL bProtoAlso) {
   CXFA_Node* pNode = this;
   while (pNode) {
     void* pVal;
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule &&
         (pModule->m_ValueMap.Lookup(pKey, pVal) ||
          pModule->m_BufferMap.Lookup(pKey, (XFA_MAPDATABLOCK*&)pVal))) {
       return TRUE;
     }
     pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
                 ? pNode->GetTemplateNode()
-                : NULL;
+                : nullptr;
   }
   return FALSE;
 }
 void CXFA_Node::RemoveMapModuleKey(void* pKey) {
   XFA_MAPMODULEDATA* pModule = GetMapModuleData();
   if (!pModule)
     return;
 
   if (pKey) {
-    XFA_MAPDATABLOCK* pBuffer = NULL;
+    XFA_MAPDATABLOCK* pBuffer = nullptr;
     pModule->m_BufferMap.Lookup(pKey, pBuffer);
     if (pBuffer) {
       if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
         pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
       }
       FX_Free(pBuffer);
     }
     pModule->m_BufferMap.RemoveKey(pKey);
     pModule->m_ValueMap.RemoveKey(pKey);
   } else {
@@ skipping 39 matching lines @@
       continue;
     }
     if (pSrcBuffer->pCallbackInfo && pSrcBuffer->pCallbackInfo->pFree &&
         !pSrcBuffer->pCallbackInfo->pCopy) {
       if (pBuffer) {
         pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
         pDstModuleData->m_BufferMap.RemoveKey(pKey);
       }
       continue;
     }
-    if (pBuffer == NULL) {
+    if (!pBuffer) {
       pBuffer = (XFA_MAPDATABLOCK*)FX_Alloc(
           uint8_t, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes);
     } else if (pBuffer->iBytes != pSrcBuffer->iBytes) {
       if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
         pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
       }
       pBuffer = (XFA_MAPDATABLOCK*)FX_Realloc(
           uint8_t, pBuffer, sizeof(XFA_MAPDATABLOCK) + pSrcBuffer->iBytes);
     } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
       pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
     }
-    if (pBuffer == NULL) {
+    if (!pBuffer) {
       continue;
     }
     pBuffer->pCallbackInfo = pSrcBuffer->pCallbackInfo;
     pBuffer->iBytes = pSrcBuffer->iBytes;
     FXSYS_memcpy(pBuffer->GetData(), pSrcBuffer->GetData(), pSrcBuffer->iBytes);
     if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pCopy) {
       pBuffer->pCallbackInfo->pCopy(*(void**)pBuffer->GetData());
     }
   }
 }
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pDstModule, void* pKey) {
   if (!pDstModule) {
     return;
   }
   FX_BOOL bNeedMove = TRUE;
   if (!pKey) {
     bNeedMove = FALSE;
   }
   if (pDstModule->GetClassID() != GetClassID()) {
     bNeedMove = FALSE;
   }
-  XFA_MAPMODULEDATA* pSrcModuleData = NULL;
-  XFA_MAPMODULEDATA* pDstModuleData = NULL;
+  XFA_MAPMODULEDATA* pSrcModuleData = nullptr;
+  XFA_MAPMODULEDATA* pDstModuleData = nullptr;
   if (bNeedMove) {
     pSrcModuleData = GetMapModuleData();
     if (!pSrcModuleData) {
       bNeedMove = FALSE;
     }
     pDstModuleData = pDstModule->CreateMapModuleData();
   }
   if (bNeedMove) {
     void* pBufferBlockData = pSrcModuleData->m_BufferMap.GetValueAt(pKey);
     if (pBufferBlockData) {
@@ skipping 36 matching lines @@
   m_pDocument->GetScriptContext()->CacheList(this);
 }
 CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) {
   uint32_t dwHashCode = FX_HashCode_GetW(wsName, false);
   int32_t iCount = GetLength();
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_Node* ret = Item(i);
     if (dwHashCode == ret->GetNameHash())
       return ret;
   }
-  return NULL;
+  return nullptr;
 }
 void CXFA_NodeList::Script_ListClass_Append(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CXFA_Node* pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
     if (pNode) {
       Append(pNode);
     } else {
       ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
     }
@@ skipping 77 matching lines @@
 }
 int32_t CXFA_ArrayNodeList::GetLength() {
   return m_array.GetSize();
 }
 FX_BOOL CXFA_ArrayNodeList::Append(CXFA_Node* pNode) {
   m_array.Add(pNode);
   return TRUE;
 }
 FX_BOOL CXFA_ArrayNodeList::Insert(CXFA_Node* pNewNode,
                                    CXFA_Node* pBeforeNode) {
-  if (pBeforeNode == NULL) {
+  if (!pBeforeNode) {
     m_array.Add(pNewNode);
   } else {
     int32_t iSize = m_array.GetSize();
     for (int32_t i = 0; i < iSize; ++i) {
       if (m_array[i] == pBeforeNode) {
         m_array.InsertAt(i, pNewNode);
         break;
       }
     }
   }
   return TRUE;
 }
 FX_BOOL CXFA_ArrayNodeList::Remove(CXFA_Node* pNode) {
   int32_t iSize = m_array.GetSize();
   for (int32_t i = 0; i < iSize; ++i) {
     if (m_array[i] == pNode) {
       m_array.RemoveAt(i);
       break;
     }
   }
   return TRUE;
 }
 CXFA_Node* CXFA_ArrayNodeList::Item(int32_t iIndex) {
   int32_t iSize = m_array.GetSize();
   if (iIndex >= 0 && iIndex < iSize) {
     return m_array[iIndex];
   }
-  return NULL;
+  return nullptr;
 }
 CXFA_AttachNodeList::CXFA_AttachNodeList(CXFA_Document* pDocument,
                                          CXFA_Node* pAttachNode)
     : CXFA_NodeList(pDocument) {
   m_pAttachNode = pAttachNode;
 }
 int32_t CXFA_AttachNodeList::GetLength() {
   return m_pAttachNode->CountChildren(
       XFA_ELEMENT_UNKNOWN, m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform);
 }
@@ skipping 13 matching lines @@
   return m_pAttachNode->InsertChild(pNewNode, pBeforeNode);
 }
 FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) {
   return m_pAttachNode->RemoveChild(pNode);
 }
 CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) {
   return m_pAttachNode->GetChild(
       iIndex, XFA_ELEMENT_UNKNOWN,
       m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform);
 }