Remove FX_BOOL from xfa.

xfa/fxfa/parser/xfa_document_datamerger_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_document_datamerger_imp.h"
 
 #include "core/fxcrt/fx_ext.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
@@ skipping 19 matching lines @@
   static CXFA_Node* GetParent(CXFA_Node* pDDGroupNode) {
     return pDDGroupNode->GetNodeItem(XFA_NODEITEM_Parent);
   }
 };
 
 struct RecurseRecord {
   CXFA_Node* pTemplateChild;
   CXFA_Node* pDataChild;
 };
 
-FX_BOOL GetOccurInfo(CXFA_Node* pOccurNode,
-                     int32_t& iMin,
-                     int32_t& iMax,
-                     int32_t& iInit) {
+bool GetOccurInfo(CXFA_Node* pOccurNode,
+                  int32_t& iMin,
+                  int32_t& iMax,
+                  int32_t& iInit) {
   if (!pOccurNode)
-    return FALSE;
+    return false;
 
   CXFA_Occur occur(pOccurNode);
   return occur.GetOccurInfo(iMin, iMax, iInit);
 }
 
 CXFA_Node* FormValueNode_CreateChild(CXFA_Node* pValueNode, XFA_Element iType) {
   CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   if (!pChildNode) {
     if (iType == XFA_Element::Unknown)
       return nullptr;
     pChildNode = pValueNode->GetProperty(0, iType);
   }
   return pChildNode;
 }
 
 void FormValueNode_MatchNoneCreateChild(CXFA_Node* pFormNode) {
   CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
   ASSERT(pWidgetData);
   pWidgetData->GetUIType();
 }
 
-FX_BOOL FormValueNode_SetChildContent(
-    CXFA_Node* pValueNode,
-    const CFX_WideString& wsContent,
-    XFA_Element iType = XFA_Element::Unknown) {
+bool FormValueNode_SetChildContent(CXFA_Node* pValueNode,
+                                   const CFX_WideString& wsContent,
+                                   XFA_Element iType = XFA_Element::Unknown) {
   if (!pValueNode)
-    return FALSE;
+    return false;
 
   ASSERT(pValueNode->GetPacketID() == XFA_XDPPACKET_Form);
   CXFA_Node* pChildNode = FormValueNode_CreateChild(pValueNode, iType);
   if (!pChildNode)
-    return FALSE;
+    return false;
 
   switch (pChildNode->GetObjectType()) {
     case XFA_ObjectType::ContentNode: {
       CXFA_Node* pContentRawDataNode =
           pChildNode->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         XFA_Element element = XFA_Element::Sharptext;
         if (pChildNode->GetElementType() == XFA_Element::ExData) {
           CFX_WideString wsContentType;
           pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType,
-                                   FALSE);
+                                   false);
           if (wsContentType == FX_WSTRC(L"text/html"))
             element = XFA_Element::SharpxHTML;
           else if (wsContentType == FX_WSTRC(L"text/xml"))
             element = XFA_Element::Sharpxml;
         }
         pContentRawDataNode = pChildNode->CreateSamePacketNode(element);
         pChildNode->InsertChild(pContentRawDataNode);
       }
       pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
       break;
     }
     case XFA_ObjectType::NodeC:
     case XFA_ObjectType::TextNode:
     case XFA_ObjectType::NodeV: {
       pChildNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
       break;
     }
     default:
-      ASSERT(FALSE);
+      ASSERT(false);
       break;
   }
-  return TRUE;
+  return true;
 }
 
 void CreateDataBinding(CXFA_Node* pFormNode,
                        CXFA_Node* pDataNode,
-                       FX_BOOL bDataToForm) {
+                       bool bDataToForm) {
   pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, pDataNode);
   pDataNode->AddBindItem(pFormNode);
   XFA_Element eType = pFormNode->GetElementType();
   if (eType != XFA_Element::Field && eType != XFA_Element::ExclGroup)
     return;
 
   CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
   ASSERT(pWidgetData);
   XFA_Element eUIType = pWidgetData->GetUIType();
   CXFA_Value defValue(pFormNode->GetProperty(0, XFA_Element::Value));
@@ skipping 189 matching lines @@
         FormValueNode_SetChildContent(defValue.GetNode(), wsNormalizeValue,
                                       XFA_Element::Text);
       }
       break;
     case XFA_Element::CheckButton:
       FormValueNode_SetChildContent(defValue.GetNode(), wsNormalizeValue,
                                     XFA_Element::Text);
       break;
     case XFA_Element::ExclGroup: {
       pWidgetData->SetSelectedMemberByValue(wsNormalizeValue.AsStringC(), false,
-                                            FALSE, FALSE);
+                                            false, false);
       break;
     }
     case XFA_Element::DateTimeEdit:
       FormValueNode_SetChildContent(defValue.GetNode(), wsNormalizeValue,
                                     XFA_Element::DateTime);
       break;
     case XFA_Element::NumericEdit: {
       CFX_WideString wsPicture;
       pWidgetData->GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
       if (wsPicture.IsEmpty()) {
@@ skipping 25 matching lines @@
 
 void RegisterGlobalBinding(CXFA_Document* pDocument,
                            uint32_t dwNameHash,
                            CXFA_Node* pDataNode) {
   pDocument->m_rgGlobalBinding.SetAt(dwNameHash, pDataNode);
 }
 
 CXFA_Node* ScopeMatchGlobalBinding(CXFA_Node* pDataScope,
                                    uint32_t dwNameHash,
                                    XFA_Element eMatchDataNodeType,
-                                   FX_BOOL bUpLevel) {
+                                   bool bUpLevel) {
   for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = nullptr;
        pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
        pLastDataScope = pCurDataScope,
                  pCurDataScope =
                      pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
     for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
          pDataChild;
          pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
       if (pDataChild == pLastDataScope ||
           (eMatchDataNodeType != XFA_Element::DataModel &&
            pDataChild->GetElementType() != eMatchDataNodeType) ||
           pDataChild->HasBindItem()) {
         continue;
       }
       return pDataChild;
     }
 
     for (CXFA_Node* pDataChild =
              pCurDataScope->GetFirstChildByClass(XFA_Element::DataGroup);
          pDataChild; pDataChild = pDataChild->GetNextSameClassSibling(
                          XFA_Element::DataGroup)) {
       CXFA_Node* pDataNode = ScopeMatchGlobalBinding(pDataChild, dwNameHash,
-                                                     eMatchDataNodeType, FALSE);
+                                                     eMatchDataNodeType, false);
       if (pDataNode)
         return pDataNode;
     }
     if (!bUpLevel)
       break;
   }
   return nullptr;
 }
 
 CXFA_Node* FindGlobalDataNode(CXFA_Document* pDocument,
                               CFX_WideStringC wsName,
                               CXFA_Node* pDataScope,
                               XFA_Element eMatchNodeType) {
   if (wsName.IsEmpty())
     return nullptr;
 
   uint32_t dwNameHash = FX_HashCode_GetW(wsName, false);
   CXFA_Node* pBounded = GetGlobalBinding(pDocument, dwNameHash);
   if (!pBounded) {
     pBounded =
-        ScopeMatchGlobalBinding(pDataScope, dwNameHash, eMatchNodeType, TRUE);
+        ScopeMatchGlobalBinding(pDataScope, dwNameHash, eMatchNodeType, true);
     if (pBounded)
       RegisterGlobalBinding(pDocument, dwNameHash, pBounded);
   }
   return pBounded;
 }
 
 CXFA_Node* FindOnceDataNode(CXFA_Document* pDocument,
                             CFX_WideStringC wsName,
                             CXFA_Node* pDataScope,
                             XFA_Element eMatchNodeType) {
@@ skipping 18 matching lines @@
     pLastDataScope = pCurDataScope;
   }
   return nullptr;
 }
 
 CXFA_Node* FindDataRefDataNode(CXFA_Document* pDocument,
                                CFX_WideStringC wsRef,
                                CXFA_Node* pDataScope,
                                XFA_Element eMatchNodeType,
                                CXFA_Node* pTemplateNode,
-                               FX_BOOL bForceBind,
-                               FX_BOOL bUpLevel) {
+                               bool bForceBind,
+                               bool bUpLevel) {
   uint32_t dFlags = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_BindNew;
   if (bUpLevel || wsRef != FX_WSTRC(L"name"))
     dFlags |= (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings);
 
   XFA_RESOLVENODE_RS rs;
   pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs, dFlags,
                                                 pTemplateNode);
   if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeAll ||
       rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeMidAll ||
       rs.nodes.GetSize() > 1) {
     return pDocument->GetNotBindNode(rs.nodes);
   }
 
   if (rs.dwFlags == XFA_RESOLVENODE_RSTYPE_CreateNodeOne) {
     CXFA_Object* pObject = (rs.nodes.GetSize() > 0) ? rs.nodes[0] : nullptr;
     CXFA_Node* pNode = ToNode(pObject);
     return (bForceBind || !pNode || !pNode->HasBindItem()) ? pNode : nullptr;
   }
   return nullptr;
 }
 
-FX_BOOL NeedGenerateForm(CXFA_Node* pTemplateChild,
-                         FX_BOOL bUseInstanceManager) {
+bool NeedGenerateForm(CXFA_Node* pTemplateChild, bool bUseInstanceManager) {
   XFA_Element eType = pTemplateChild->GetElementType();
   if (eType == XFA_Element::Variables)
-    return TRUE;
+    return true;
   if (pTemplateChild->IsContainerNode())
-    return FALSE;
+    return false;
   if (eType == XFA_Element::Proto ||
       (bUseInstanceManager && eType == XFA_Element::Occur)) {
-    return FALSE;
+    return false;
   }
-  return TRUE;
+  return true;
 }
 
 CXFA_Node* CloneOrMergeInstanceManager(CXFA_Document* pDocument,
                                        CXFA_Node* pFormParent,
                                        CXFA_Node* pTemplateNode,
                                        CXFA_NodeArray& subforms) {
   CFX_WideStringC wsSubformName = pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
   CFX_WideString wsInstMgrNodeName = FX_WSTRC(L"_") + wsSubformName;
   uint32_t dwInstNameHash =
       FX_HashCode_GetW(wsInstMgrNodeName.AsStringC(), false);
@@ skipping 35 matching lines @@
   pNewNode->SetCData(XFA_ATTRIBUTE_Name, wsInstMgrNodeName);
   pFormParent->InsertChild(pNewNode, nullptr);
   pNewNode->SetTemplateNode(pTemplateNode);
   return pNewNode;
 }
 
 CXFA_Node* FindMatchingDataNode(
     CXFA_Document* pDocument,
     CXFA_Node* pTemplateNode,
     CXFA_Node* pDataScope,
-    FX_BOOL& bAccessedDataDOM,
-    FX_BOOL bForceBind,
+    bool& bAccessedDataDOM,
+    bool bForceBind,
     CXFA_NodeIteratorTemplate<CXFA_Node,
                               CXFA_TraverseStrategy_XFAContainerNode>*
         pIterator,
-    FX_BOOL& bSelfMatch,
+    bool& bSelfMatch,
     XFA_ATTRIBUTEENUM& eBindMatch,
-    FX_BOOL bUpLevel) {
-  FX_BOOL bOwnIterator = FALSE;
+    bool bUpLevel) {
+  bool bOwnIterator = false;
   if (!pIterator) {
-    bOwnIterator = TRUE;
+    bOwnIterator = true;
     pIterator = new CXFA_NodeIteratorTemplate<
         CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>(pTemplateNode);
   }
 
   CXFA_Node* pResult = nullptr;
   for (CXFA_Node* pCurTemplateNode = pIterator->GetCurrent();
        pCurTemplateNode;) {
     XFA_Element eMatchNodeType;
     switch (pCurTemplateNode->GetElementType()) {
       case XFA_Element::Subform:
@@ skipping 24 matching lines @@
         pCurTemplateNode->GetFirstChildByClass(XFA_Element::Bind);
     XFA_ATTRIBUTEENUM eMatch =
         pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
                           : XFA_ATTRIBUTEENUM_Once;
     eBindMatch = eMatch;
     switch (eMatch) {
       case XFA_ATTRIBUTEENUM_None:
         pCurTemplateNode = pIterator->MoveToNext();
         continue;
       case XFA_ATTRIBUTEENUM_Global:
-        bAccessedDataDOM = TRUE;
+        bAccessedDataDOM = true;
         if (!bForceBind) {
           pCurTemplateNode = pIterator->MoveToNext();
           continue;
         }
         if (eMatchNodeType == XFA_Element::DataValue ||
             (eMatchNodeType == XFA_Element::DataGroup &&
              XFA_FieldIsMultiListBox(pTemplateNodeBind))) {
           CXFA_Node* pGlobalBindNode = FindGlobalDataNode(
               pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name),
               pDataScope, eMatchNodeType);
           if (!pGlobalBindNode) {
             pCurTemplateNode = pIterator->MoveToNext();
             continue;
           }
           pResult = pGlobalBindNode;
           break;
         }
       case XFA_ATTRIBUTEENUM_Once: {
-        bAccessedDataDOM = TRUE;
+        bAccessedDataDOM = true;
         CXFA_Node* pOnceBindNode = FindOnceDataNode(
             pDocument, pCurTemplateNode->GetCData(XFA_ATTRIBUTE_Name),
             pDataScope, eMatchNodeType);
         if (!pOnceBindNode) {
           pCurTemplateNode = pIterator->MoveToNext();
           continue;
         }
         pResult = pOnceBindNode;
         break;
       }
       case XFA_ATTRIBUTEENUM_DataRef: {
-        bAccessedDataDOM = TRUE;
+        bAccessedDataDOM = true;
         CXFA_Node* pDataRefBindNode = FindDataRefDataNode(
             pDocument, pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref),
             pDataScope, eMatchNodeType, pTemplateNode, bForceBind, bUpLevel);
         if (pDataRefBindNode &&
             pDataRefBindNode->GetElementType() == eMatchNodeType) {
           pResult = pDataRefBindNode;
         }
         if (!pResult) {
           pCurTemplateNode = pIterator->SkipChildrenAndMoveToNext();
           continue;
         }
         break;
       }
       default:
         break;
     }
     if (pCurTemplateNode == pTemplateNode && pResult)
-      bSelfMatch = TRUE;
+      bSelfMatch = true;
     break;
   }
   if (bOwnIterator)
     delete pIterator;
   return pResult;
 }
 
 void SortRecurseRecord(CFX_ArrayTemplate<RecurseRecord>& rgRecords,
                        CXFA_Node* pDataScope,
-                       FX_BOOL bChoiceMode) {
+                       bool bChoiceMode) {
   int32_t iCount = rgRecords.GetSize();
   CFX_ArrayTemplate<RecurseRecord> rgResultRecord;
   for (CXFA_Node* pChildNode = pDataScope->GetNodeItem(XFA_NODEITEM_FirstChild);
        pChildNode;
        pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     for (int32_t i = 0; i < iCount; i++) {
       CXFA_Node* pNode = rgRecords[i].pDataChild;
       if (pChildNode == pNode) {
         RecurseRecord sNewRecord = {rgRecords[i].pTemplateChild, pNode};
         rgResultRecord.Add(sNewRecord);
@@ skipping 16 matching lines @@
     }
     rgRecords.RemoveAll();
     rgRecords.Copy(rgResultRecord);
   }
 }
 
 CXFA_Node* CopyContainer_SubformSet(CXFA_Document* pDocument,
                                     CXFA_Node* pTemplateNode,
                                     CXFA_Node* pFormParentNode,
                                     CXFA_Node* pDataScope,
-                                    FX_BOOL bOneInstance,
-                                    FX_BOOL bDataMerge) {
+                                    bool bOneInstance,
+                                    bool bDataMerge) {
   XFA_Element eType = pTemplateNode->GetElementType();
   CXFA_Node* pOccurNode = nullptr;
   CXFA_Node* pFirstInstance = nullptr;
-  FX_BOOL bUseInstanceManager =
+  bool bUseInstanceManager =
       pFormParentNode->GetElementType() != XFA_Element::Area;
   CXFA_Node* pInstMgrNode = nullptr;
   CXFA_NodeArray subformArray;
   CXFA_NodeArray* pSearchArray = nullptr;
   if (!bOneInstance &&
       (eType == XFA_Element::SubformSet || eType == XFA_Element::Subform)) {
     pInstMgrNode = bUseInstanceManager ? CloneOrMergeInstanceManager(
                                              pDocument, pFormParentNode,
                                              pTemplateNode, subformArray)
                                        : nullptr;
     if (CXFA_Node* pOccurTemplateNode =
             pTemplateNode->GetFirstChildByClass(XFA_Element::Occur)) {
       pOccurNode = pInstMgrNode ? XFA_NodeMerge_CloneOrMergeContainer(
                                       pDocument, pInstMgrNode,
-                                      pOccurTemplateNode, FALSE, nullptr)
+                                      pOccurTemplateNode, false, nullptr)
                                 : pOccurTemplateNode;
     } else if (pInstMgrNode) {
       pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_Element::Occur);
       if (pOccurNode)
         pOccurNode->ClearFlag(XFA_NodeFlag_UnusedNode);
     }
     if (pInstMgrNode) {
       pInstMgrNode->SetFlag(XFA_NodeFlag_Initialized, true);
       pSearchArray = &subformArray;
       if (pFormParentNode->GetElementType() == XFA_Element::PageArea) {
-        bOneInstance = TRUE;
+        bOneInstance = true;
         if (subformArray.GetSize() < 1)
           pSearchArray = nullptr;
       } else if ((pTemplateNode->GetNameHash() == 0) &&
                  (subformArray.GetSize() < 1)) {
         pSearchArray = nullptr;
       }
     }
   }
 
   int32_t iMax = 1;
   int32_t iInit = 1;
   int32_t iMin = 1;
   if (!bOneInstance)
     GetOccurInfo(pOccurNode, iMin, iMax, iInit);
 
   XFA_ATTRIBUTEENUM eRelation =
       eType == XFA_Element::SubformSet
           ? pTemplateNode->GetEnum(XFA_ATTRIBUTE_Relation)
           : XFA_ATTRIBUTEENUM_Ordered;
   int32_t iCurRepeatIndex = 0;
   XFA_ATTRIBUTEENUM eParentBindMatch = XFA_ATTRIBUTEENUM_None;
   if (bDataMerge) {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
         sNodeIterator(pTemplateNode);
-    FX_BOOL bAccessedDataDOM = FALSE;
+    bool bAccessedDataDOM = false;
     if (eType == XFA_Element::SubformSet || eType == XFA_Element::Area) {
       sNodeIterator.MoveToNext();
     } else {
       CFX_MapPtrTemplate<CXFA_Node*, CXFA_Node*> subformMapArray;
       CXFA_NodeArray nodeArray;
       for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
-        FX_BOOL bSelfMatch = FALSE;
+        bool bSelfMatch = false;
         XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
         CXFA_Node* pDataNode = FindMatchingDataNode(
-            pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, FALSE,
-            &sNodeIterator, bSelfMatch, eBindMatch, TRUE);
+            pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, false,
+            &sNodeIterator, bSelfMatch, eBindMatch, true);
         if (!pDataNode || sNodeIterator.GetCurrent() != pTemplateNode)
           break;
 
         eParentBindMatch = eBindMatch;
         CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
-            pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
+            pDocument, pFormParentNode, pTemplateNode, false, pSearchArray);
         if (!pFirstInstance)
           pFirstInstance = pSubformNode;
 
-        CreateDataBinding(pSubformNode, pDataNode, TRUE);
+        CreateDataBinding(pSubformNode, pDataNode, true);
         ASSERT(pSubformNode);
         subformMapArray.SetAt(pSubformNode, pDataNode);
         nodeArray.Add(pSubformNode);
       }
 
       subformMapArray.GetStartPosition();
       for (int32_t iIndex = 0; iIndex < nodeArray.GetSize(); iIndex++) {
         CXFA_Node* pSubform = nodeArray[iIndex];
         CXFA_Node* pDataNode =
             reinterpret_cast<CXFA_Node*>(subformMapArray.GetValueAt(pSubform));
         for (CXFA_Node* pTemplateChild =
                  pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
           if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubform,
-                                                pTemplateChild, TRUE, nullptr);
+                                                pTemplateChild, true, nullptr);
           } else if (pTemplateChild->IsContainerNode()) {
             pDocument->DataMerge_CopyContainer(pTemplateChild, pSubform,
-                                               pDataNode, FALSE, TRUE, FALSE);
+                                               pDataNode, false, true, false);
           }
         }
       }
       subformMapArray.RemoveAll();
     }
 
     for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
-      FX_BOOL bSelfMatch = FALSE;
+      bool bSelfMatch = false;
       XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
       if (!FindMatchingDataNode(pDocument, pTemplateNode, pDataScope,
-                                bAccessedDataDOM, FALSE, &sNodeIterator,
-                                bSelfMatch, eBindMatch, TRUE)) {
+                                bAccessedDataDOM, false, &sNodeIterator,
+                                bSelfMatch, eBindMatch, true)) {
         break;
       }
       if (eBindMatch == XFA_ATTRIBUTEENUM_DataRef &&
           eParentBindMatch == XFA_ATTRIBUTEENUM_DataRef) {
         break;
       }
 
       if (eRelation == XFA_ATTRIBUTEENUM_Choice ||
           eRelation == XFA_ATTRIBUTEENUM_Unordered) {
         CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
-            pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
+            pDocument, pFormParentNode, pTemplateNode, false, pSearchArray);
         ASSERT(pSubformSetNode);
         if (!pFirstInstance)
           pFirstInstance = pSubformSetNode;
 
         CFX_ArrayTemplate<RecurseRecord> rgItemMatchList;
         CFX_ArrayTemplate<CXFA_Node*> rgItemUnmatchList;
         for (CXFA_Node* pTemplateChild =
                  pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
           if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
-                                                pTemplateChild, TRUE, nullptr);
+                                                pTemplateChild, true, nullptr);
           } else if (pTemplateChild->IsContainerNode()) {
-            bSelfMatch = FALSE;
+            bSelfMatch = false;
             eBindMatch = XFA_ATTRIBUTEENUM_None;
             if (eRelation != XFA_ATTRIBUTEENUM_Ordered) {
               CXFA_Node* pDataMatch = FindMatchingDataNode(
                   pDocument, pTemplateChild, pDataScope, bAccessedDataDOM,
-                  FALSE, nullptr, bSelfMatch, eBindMatch, TRUE);
+                  false, nullptr, bSelfMatch, eBindMatch, true);
               if (pDataMatch) {
                 RecurseRecord sNewRecord = {pTemplateChild, pDataMatch};
                 if (bSelfMatch)
                   rgItemMatchList.InsertAt(0, sNewRecord);
                 else
                   rgItemMatchList.Add(sNewRecord);
               } else {
                 rgItemUnmatchList.Add(pTemplateChild);
               }
             } else {
               rgItemUnmatchList.Add(pTemplateChild);
             }
           }
         }
 
         switch (eRelation) {
           case XFA_ATTRIBUTEENUM_Choice: {
             ASSERT(rgItemMatchList.GetSize());
-            SortRecurseRecord(rgItemMatchList, pDataScope, TRUE);
+            SortRecurseRecord(rgItemMatchList, pDataScope, true);
             pDocument->DataMerge_CopyContainer(
                 rgItemMatchList[0].pTemplateChild, pSubformSetNode, pDataScope,
-                FALSE, TRUE, TRUE);
+                false, true, true);
             break;
           }
           case XFA_ATTRIBUTEENUM_Unordered: {
             if (rgItemMatchList.GetSize()) {
-              SortRecurseRecord(rgItemMatchList, pDataScope, FALSE);
+              SortRecurseRecord(rgItemMatchList, pDataScope, false);
               for (int32_t i = 0, count = rgItemMatchList.GetSize(); i < count;
                    i++) {
                 pDocument->DataMerge_CopyContainer(
                     rgItemMatchList[i].pTemplateChild, pSubformSetNode,
-                    pDataScope, FALSE, TRUE, TRUE);
+                    pDataScope, false, true, true);
               }
             }
             for (int32_t i = 0, count = rgItemUnmatchList.GetSize(); i < count;
                  i++) {
               pDocument->DataMerge_CopyContainer(rgItemUnmatchList[i],
                                                  pSubformSetNode, pDataScope,
-                                                 FALSE, TRUE, TRUE);
+                                                 false, true, true);
             }
             break;
           }
           default:
             break;
         }
       } else {
         CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
-            pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
+            pDocument, pFormParentNode, pTemplateNode, false, pSearchArray);
         ASSERT(pSubformSetNode);
         if (!pFirstInstance)
           pFirstInstance = pSubformSetNode;
 
         for (CXFA_Node* pTemplateChild =
                  pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
           if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
-                                                pTemplateChild, TRUE, nullptr);
+                                                pTemplateChild, true, nullptr);
           } else if (pTemplateChild->IsContainerNode()) {
             pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode,
-                                               pDataScope, FALSE, TRUE, TRUE);
+                                               pDataScope, false, true, true);
           }
         }
       }
     }
 
-    if (iCurRepeatIndex == 0 && bAccessedDataDOM == FALSE) {
+    if (iCurRepeatIndex == 0 && bAccessedDataDOM == false) {
       int32_t iLimit = iMax;
       if (pInstMgrNode && pTemplateNode->GetNameHash() == 0) {
         iLimit = subformArray.GetSize();
         if (iLimit < iMin)
           iLimit = iInit;
       }
 
       for (; (iLimit < 0 || iCurRepeatIndex < iLimit); iCurRepeatIndex++) {
         if (pInstMgrNode) {
           if (pSearchArray && pSearchArray->GetSize() < 1) {
             if (pTemplateNode->GetNameHash() != 0)
               break;
             pSearchArray = nullptr;
           }
         } else if (!XFA_DataMerge_FindFormDOMInstance(
                        pDocument, pTemplateNode->GetElementType(),
                        pTemplateNode->GetNameHash(), pFormParentNode)) {
           break;
         }
         CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
-            pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
+            pDocument, pFormParentNode, pTemplateNode, false, pSearchArray);
         ASSERT(pSubformNode);
         if (!pFirstInstance)
           pFirstInstance = pSubformNode;
 
         for (CXFA_Node* pTemplateChild =
                  pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
           if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformNode,
-                                                pTemplateChild, TRUE, nullptr);
+                                                pTemplateChild, true, nullptr);
           } else if (pTemplateChild->IsContainerNode()) {
             pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformNode,
-                                               pDataScope, FALSE, TRUE, TRUE);
+                                               pDataScope, false, true, true);
           }
         }
       }
     }
   }
 
   int32_t iMinimalLimit = iCurRepeatIndex == 0 ? iInit : iMin;
   for (; iCurRepeatIndex < iMinimalLimit; iCurRepeatIndex++) {
     CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
-        pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
+        pDocument, pFormParentNode, pTemplateNode, false, pSearchArray);
     ASSERT(pSubformSetNode);
     if (!pFirstInstance)
       pFirstInstance = pSubformSetNode;
 
-    FX_BOOL bFound = FALSE;
+    bool bFound = false;
     for (CXFA_Node* pTemplateChild =
              pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
          pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                              XFA_NODEITEM_NextSibling)) {
       if (NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
         XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
-                                            pTemplateChild, TRUE, nullptr);
+                                            pTemplateChild, true, nullptr);
       } else if (pTemplateChild->IsContainerNode()) {
         if (bFound && eRelation == XFA_ATTRIBUTEENUM_Choice)
           continue;
 
         pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode,
-                                           pDataScope, FALSE, bDataMerge, TRUE);
-        bFound = TRUE;
+                                           pDataScope, false, bDataMerge, true);
+        bFound = true;
       }
     }
   }
   return pFirstInstance;
 }
 
 CXFA_Node* CopyContainer_Field(CXFA_Document* pDocument,
                                CXFA_Node* pTemplateNode,
                                CXFA_Node* pFormNode,
                                CXFA_Node* pDataScope,
-                               FX_BOOL bDataMerge,
-                               FX_BOOL bUpLevel) {
+                               bool bDataMerge,
+                               bool bUpLevel) {
   CXFA_Node* pFieldNode = XFA_NodeMerge_CloneOrMergeContainer(
-      pDocument, pFormNode, pTemplateNode, FALSE, nullptr);
+      pDocument, pFormNode, pTemplateNode, false, nullptr);
   ASSERT(pFieldNode);
   for (CXFA_Node* pTemplateChildNode =
            pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pTemplateChildNode; pTemplateChildNode = pTemplateChildNode->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
-    if (NeedGenerateForm(pTemplateChildNode, TRUE)) {
+    if (NeedGenerateForm(pTemplateChildNode, true)) {
       XFA_NodeMerge_CloneOrMergeContainer(pDocument, pFieldNode,
-                                          pTemplateChildNode, TRUE, nullptr);
+                                          pTemplateChildNode, true, nullptr);
     } else if (pTemplateNode->GetElementType() == XFA_Element::ExclGroup &&
                pTemplateChildNode->IsContainerNode()) {
       if (pTemplateChildNode->GetElementType() == XFA_Element::Field) {
         CopyContainer_Field(pDocument, pTemplateChildNode, pFieldNode, nullptr,
-                            FALSE, TRUE);
+                            false, true);
       }
     }
   }
   if (bDataMerge) {
-    FX_BOOL bAccessedDataDOM = FALSE;
-    FX_BOOL bSelfMatch = FALSE;
+    bool bAccessedDataDOM = false;
+    bool bSelfMatch = false;
     XFA_ATTRIBUTEENUM eBindMatch;
     CXFA_Node* pDataNode = FindMatchingDataNode(
-        pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, nullptr,
+        pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, true, nullptr,
         bSelfMatch, eBindMatch, bUpLevel);
     if (pDataNode)
-      CreateDataBinding(pFieldNode, pDataNode, TRUE);
+      CreateDataBinding(pFieldNode, pDataNode, true);
   } else {
     FormValueNode_MatchNoneCreateChild(pFieldNode);
   }
   return pFieldNode;
 }
 
 CXFA_Node* MaybeCreateDataNode(CXFA_Document* pDocument,
                                CXFA_Node* pDataParent,
                                XFA_Element eNodeType,
                                const CFX_WideString& wsName) {
@@ skipping 44 matching lines @@
     pDataNode->SetDataDescriptionNode(pDDNode);
     pDataNode->SetFlag(XFA_NodeFlag_Initialized, false);
     return pDataNode;
   }
   return nullptr;
 }
 
 void UpdateBindingRelations(CXFA_Document* pDocument,
                             CXFA_Node* pFormNode,
                             CXFA_Node* pDataScope,
-                            FX_BOOL bDataRef,
-                            FX_BOOL bParentDataRef) {
-  FX_BOOL bMatchRef = TRUE;
+                            bool bDataRef,
+                            bool bParentDataRef) {
+  bool bMatchRef = true;
   XFA_Element eType = pFormNode->GetElementType();
   CXFA_Node* pDataNode = pFormNode->GetBindData();
   if (eType == XFA_Element::Subform || eType == XFA_Element::ExclGroup ||
       eType == XFA_Element::Field) {
     CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
     CXFA_Node* pTemplateNodeBind =
         pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_Element::Bind)
                       : nullptr;
     XFA_ATTRIBUTEENUM eMatch =
         pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
@@ skipping 10 matching lines @@
                 pFormNode->GetEnum(XFA_ATTRIBUTE_Scope) !=
                     XFA_ATTRIBUTEENUM_None) {
               XFA_Element eDataNodeType = (eType == XFA_Element::Subform ||
                                            XFA_FieldIsMultiListBox(pFormNode))
                                               ? XFA_Element::DataGroup
                                               : XFA_Element::DataValue;
               pDataNode = MaybeCreateDataNode(
                   pDocument, pDataScope, eDataNodeType,
                   CFX_WideString(pFormNode->GetCData(XFA_ATTRIBUTE_Name)));
               if (pDataNode)
-                CreateDataBinding(pFormNode, pDataNode, FALSE);
+                CreateDataBinding(pFormNode, pDataNode, false);
             }
             if (!pDataNode)
               FormValueNode_MatchNoneCreateChild(pFormNode);
 
           } else {
             CXFA_Node* pDataParent =
                 pDataNode->GetNodeItem(XFA_NODEITEM_Parent);
             if (pDataParent != pDataScope) {
               ASSERT(pDataParent);
               pDataParent->RemoveChild(pDataNode);
@@ skipping 11 matching lines @@
               XFA_Element eDataNodeType = (eType == XFA_Element::Subform ||
                                            XFA_FieldIsMultiListBox(pFormNode))
                                               ? XFA_Element::DataGroup
                                               : XFA_Element::DataValue;
               CXFA_Node* pRecordNode =
                   ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
               pDataNode = MaybeCreateDataNode(
                   pDocument, pRecordNode, eDataNodeType,
                   CFX_WideString(pFormNode->GetCData(XFA_ATTRIBUTE_Name)));
               if (pDataNode) {
-                CreateDataBinding(pFormNode, pDataNode, FALSE);
+                CreateDataBinding(pFormNode, pDataNode, false);
                 RegisterGlobalBinding(pDocument, pFormNode->GetNameHash(),
                                       pDataNode);
               }
             } else {
-              CreateDataBinding(pFormNode, pDataNode, TRUE);
+              CreateDataBinding(pFormNode, pDataNode, true);
             }
           }
           if (!pDataNode)
             FormValueNode_MatchNoneCreateChild(pFormNode);
         }
         break;
       case XFA_ATTRIBUTEENUM_DataRef: {
         bMatchRef = bDataRef;
-        bParentDataRef = TRUE;
+        bParentDataRef = true;
         if (!pDataNode && bDataRef) {
           CFX_WideStringC wsRef =
               pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref);
           uint32_t dFlags =
               XFA_RESOLVENODE_Children | XFA_RESOLVENODE_CreateNode;
           XFA_RESOLVENODE_RS rs;
           pDocument->GetScriptContext()->ResolveObjects(pDataScope, wsRef, rs,
                                                         dFlags, pTemplateNode);
           CXFA_Object* pObject =
               (rs.nodes.GetSize() > 0) ? rs.nodes[0] : nullptr;
@@ skipping 81 matching lines @@
         pFormChild->GetNameHash() == dwNameHash && pFormChild->IsUnusedNode()) {
       return pFormChild;
     }
   }
   return nullptr;
 }
 
 CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument,
                                                CXFA_Node* pFormParent,
                                                CXFA_Node* pTemplateNode,
-                                               FX_BOOL bRecursive,
+                                               bool bRecursive,
                                                CXFA_NodeArray* pSubformArray) {
   CXFA_Node* pExistingNode = nullptr;
   if (!pSubformArray) {
     pExistingNode = XFA_DataMerge_FindFormDOMInstance(
         pDocument, pTemplateNode->GetElementType(),
         pTemplateNode->GetNameHash(), pFormParent);
   } else if (pSubformArray->GetSize() > 0) {
     pExistingNode = pSubformArray->GetAt(0);
     pSubformArray->RemoveAt(0);
   }
 
   if (pExistingNode) {
     if (pSubformArray) {
       pFormParent->InsertChild(pExistingNode);
     } else if (pExistingNode->IsContainerNode()) {
       pFormParent->RemoveChild(pExistingNode);
       pFormParent->InsertChild(pExistingNode);
     }
     pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
     pExistingNode->SetTemplateNode(pTemplateNode);
     if (bRecursive && pExistingNode->GetElementType() != XFA_Element::Items) {
       for (CXFA_Node* pTemplateChild =
                pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
            pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
-        if (NeedGenerateForm(pTemplateChild, TRUE)) {
+        if (NeedGenerateForm(pTemplateChild, true)) {
           XFA_NodeMerge_CloneOrMergeContainer(
               pDocument, pExistingNode, pTemplateChild, bRecursive, nullptr);
         }
       }
     }
     pExistingNode->SetFlag(XFA_NodeFlag_Initialized, true);
     return pExistingNode;
   }
 
-  CXFA_Node* pNewNode = pTemplateNode->CloneTemplateToForm(FALSE);
+  CXFA_Node* pNewNode = pTemplateNode->CloneTemplateToForm(false);
   pFormParent->InsertChild(pNewNode, nullptr);
   if (bRecursive) {
     for (CXFA_Node* pTemplateChild =
              pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
          pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                              XFA_NODEITEM_NextSibling)) {
-      if (NeedGenerateForm(pTemplateChild, TRUE)) {
-        CXFA_Node* pNewChild = pTemplateChild->CloneTemplateToForm(TRUE);
+      if (NeedGenerateForm(pTemplateChild, true)) {
+        CXFA_Node* pNewChild = pTemplateChild->CloneTemplateToForm(true);
         pNewNode->InsertChild(pNewChild, nullptr);
       }
     }
   }
   return pNewNode;
 }
 
 CXFA_Node* XFA_DataMerge_FindDataScope(CXFA_Node* pParentFormNode) {
   for (CXFA_Node* pRootBoundNode = pParentFormNode;
        pRootBoundNode && pRootBoundNode->IsContainerNode();
        pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
     CXFA_Node* pDataScope = pRootBoundNode->GetBindData();
     if (pDataScope)
       return pDataScope;
   }
   return ToNode(
       pParentFormNode->GetDocument()->GetXFAObject(XFA_HASHCODE_Data));
 }
 
 CXFA_Node* CXFA_Document::DataMerge_CopyContainer(CXFA_Node* pTemplateNode,
                                                   CXFA_Node* pFormNode,
                                                   CXFA_Node* pDataScope,
-                                                  FX_BOOL bOneInstance,
-                                                  FX_BOOL bDataMerge,
-                                                  FX_BOOL bUpLevel) {
+                                                  bool bOneInstance,
+                                                  bool bDataMerge,
+                                                  bool bUpLevel) {
   switch (pTemplateNode->GetElementType()) {
     case XFA_Element::SubformSet:
     case XFA_Element::Subform:
     case XFA_Element::Area:
     case XFA_Element::PageArea:
       return CopyContainer_SubformSet(this, pTemplateNode, pFormNode,
                                       pDataScope, bOneInstance, bDataMerge);
     case XFA_Element::ExclGroup:
     case XFA_Element::Field:
     case XFA_Element::Draw:
     case XFA_Element::ContentArea:
       return CopyContainer_Field(this, pTemplateNode, pFormNode, pDataScope,
                                  bDataMerge, bUpLevel);
     case XFA_Element::PageSet:
     case XFA_Element::Variables:
       break;
     default:
-      ASSERT(FALSE);
+      ASSERT(false);
       break;
   }
   return nullptr;
 }
 
 void CXFA_Document::DataMerge_UpdateBindingRelations(
     CXFA_Node* pFormUpdateRoot) {
   CXFA_Node* pDataScope = XFA_DataMerge_FindDataScope(
       pFormUpdateRoot->GetNodeItem(XFA_NODEITEM_Parent));
   if (!pDataScope)
     return;
 
-  UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, FALSE, FALSE);
-  UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, TRUE, FALSE);
+  UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, false, false);
+  UpdateBindingRelations(this, pFormUpdateRoot, pDataScope, true, false);
 }
 
 CXFA_Node* CXFA_Document::GetNotBindNode(CXFA_ObjArray& arrayNodes) {
   for (int32_t i = 0; i < arrayNodes.GetSize(); i++) {
     CXFA_Node* pNode = arrayNodes[i]->AsNode();
     if (pNode && !pNode->HasBindItem())
       return pNode;
   }
   return nullptr;
 }
@@ skipping 56 matching lines @@
       dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash)
                       : nullptr;
   if (!pTemplateChosen ||
       pTemplateChosen->GetElementType() != XFA_Element::Subform) {
     pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_Element::Subform);
   }
   if (!pTemplateChosen)
     return;
 
   CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_Element::Form);
-  FX_BOOL bEmptyForm = FALSE;
+  bool bEmptyForm = false;
   if (!pFormRoot) {
-    bEmptyForm = TRUE;
+    bEmptyForm = true;
     pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_Element::Form);
     ASSERT(pFormRoot);
     pFormRoot->SetCData(XFA_ATTRIBUTE_Name, L"form");
     m_pRootNode->InsertChild(pFormRoot, nullptr);
   } else {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
         sIterator(pFormRoot);
     for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode;
          pNode = sIterator.MoveToNext()) {
       pNode->SetFlag(XFA_NodeFlag_UnusedNode, true);
     }
   }
 
   CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
-      this, pFormRoot, pTemplateChosen, FALSE, nullptr);
+      this, pFormRoot, pTemplateChosen, false, nullptr);
   ASSERT(pSubformSetNode);
   if (!pDataTopLevel) {
     CFX_WideStringC wsFormName = pSubformSetNode->GetCData(XFA_ATTRIBUTE_Name);
     CFX_WideString wsDataTopLevelName(wsFormName.IsEmpty() ? L"form"
                                                            : wsFormName);
     CFDE_XMLElement* pDataTopLevelXMLNode =
         new CFDE_XMLElement(wsDataTopLevelName);
 
     pDataTopLevel = CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataGroup);
     pDataTopLevel->SetCData(XFA_ATTRIBUTE_Name, wsDataTopLevelName);
     pDataTopLevel->SetXMLMappingNode(pDataTopLevelXMLNode);
     CXFA_Node* pBeforeNode = pDataRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
     pDataRoot->InsertChild(pDataTopLevel, pBeforeNode);
   }
 
   ASSERT(pDataTopLevel);
-  CreateDataBinding(pSubformSetNode, pDataTopLevel, TRUE);
+  CreateDataBinding(pSubformSetNode, pDataTopLevel, true);
   for (CXFA_Node* pTemplateChild =
            pTemplateChosen->GetNodeItem(XFA_NODEITEM_FirstChild);
        pTemplateChild;
        pTemplateChild = pTemplateChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (NeedGenerateForm(pTemplateChild, TRUE)) {
+    if (NeedGenerateForm(pTemplateChild, true)) {
       XFA_NodeMerge_CloneOrMergeContainer(this, pSubformSetNode, pTemplateChild,
-                                          TRUE, nullptr);
+                                          true, nullptr);
     } else if (pTemplateChild->IsContainerNode()) {
       DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, pDataTopLevel,
-                              FALSE, TRUE, TRUE);
+                              false, true, true);
     }
   }
   if (pDDRoot)
     UpdateDataRelation(pDataRoot, pDDRoot);
 
   DataMerge_UpdateBindingRelations(pSubformSetNode);
   CXFA_Node* pPageSetNode =
       pSubformSetNode->GetFirstChildByClass(XFA_Element::PageSet);
   while (pPageSetNode) {
     m_pPendingPageSet.Add(pPageSetNode);
@@ skipping 21 matching lines @@
         pNode->SetFlag(XFA_NodeFlag_Initialized, true);
         pNode = sIterator.MoveToNext();
       }
     } else {
       pNode->SetFlag(XFA_NodeFlag_Initialized, true);
       pNode = sIterator.MoveToNext();
     }
   }
 }
 
-void CXFA_Document::DoDataRemerge(FX_BOOL bDoDataMerge) {
+void CXFA_Document::DoDataRemerge(bool bDoDataMerge) {
   CXFA_Node* pFormRoot = ToNode(GetXFAObject(XFA_HASHCODE_Form));
   if (pFormRoot) {
     while (CXFA_Node* pNode = pFormRoot->GetNodeItem(XFA_NODEITEM_FirstChild))
       pFormRoot->RemoveChild(pNode);
     pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
   }
   m_rgGlobalBinding.RemoveAll();
   if (bDoDataMerge)
     DoDataMerge();
 
   CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor();
-  pLayoutProcessor->SetForceReLayout(TRUE);
+  pLayoutProcessor->SetForceReLayout(true);
 }