Split the XFA_OBJECTTYPE enum into two parts.

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/include/fx_ext.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
@@ skipping 46 matching lines @@
 static FX_BOOL XFA_DataMerge_FormValueNode_SetChildContent(
     CXFA_Node* pValueNode,
     const CFX_WideString& wsContent,
     XFA_ELEMENT iType = XFA_ELEMENT_UNKNOWN) {
   if (!pValueNode) {
     return FALSE;
   }
   ASSERT(pValueNode->GetPacketID() == XFA_XDPPACKET_Form);
   CXFA_Node* pChildNode =
       XFA_DataMerge_FormValueNode_CreateChild(pValueNode, iType);
-  if (!pChildNode) {
+  if (!pChildNode)
     return FALSE;
-  }
-  XFA_OBJECTTYPE objectType = pChildNode->GetObjectType();
-  switch (objectType) {
-    case XFA_OBJECTTYPE_ContentNode: {
+
+  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->GetClassID() == XFA_ELEMENT_ExData) {
           CFX_WideString wsContentType;
           pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType,
                                    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: {
+    case XFA_ObjectType::NodeC:
+    case XFA_ObjectType::TextNode:
+    case XFA_ObjectType::NodeV: {
       pChildNode->SetCData(XFA_ATTRIBUTE_Value, wsContent);
     } break;
     default:
       ASSERT(FALSE);
       break;
   }
   return TRUE;
 }
 static void XFA_DataMerge_CreateDataBinding(CXFA_Node* pFormNode,
                                             CXFA_Node* pDataNode,
@@ skipping 361 matching lines @@
   return NULL;
 }
 CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument,
                                              XFA_ELEMENT eClassID,
                                              uint32_t dwNameHash,
                                              CXFA_Node* pFormParent) {
   CXFA_Node* pFormChild = pFormParent->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pFormChild;
        pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pFormChild->GetClassID() == eClassID &&
-        pFormChild->GetNameHash() == dwNameHash &&
-        pFormChild->HasFlag(XFA_NODEFLAG_UnusedNode)) {
+        pFormChild->GetNameHash() == dwNameHash && pFormChild->IsUnusedNode()) {
       return pFormChild;
     }
   }
   return NULL;
 }
 static FX_BOOL XFA_NeedGenerateForm(CXFA_Node* pTemplateChild,
                                     FX_BOOL bUseInstanceManager = TRUE) {
   XFA_ELEMENT eType = pTemplateChild->GetClassID();
   if (eType == XFA_ELEMENT_Variables) {
     return TRUE;
   }
-  if (pTemplateChild->GetObjectType() == XFA_OBJECTTYPE_ContainerNode) {
+  if (pTemplateChild->IsContainerNode()) {
     return FALSE;
   }
   if (eType == XFA_ELEMENT_Proto ||
       (bUseInstanceManager && eType == XFA_ELEMENT_Occur)) {
     return FALSE;
   }
   return TRUE;
 }
 CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument,
                                                CXFA_Node* pFormParent,
                                                CXFA_Node* pTemplateNode,
                                                FX_BOOL bRecursive,
                                                CXFA_NodeArray* pSubformArray) {
   CXFA_Node* pExistingNode = NULL;
   if (pSubformArray == NULL) {
     pExistingNode = XFA_DataMerge_FindFormDOMInstance(
         pDocument, pTemplateNode->GetClassID(), 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->ClearFlag(XFA_NodeFlag_UnusedNode);
     pExistingNode->SetTemplateNode(pTemplateNode);
     if (bRecursive && pExistingNode->GetClassID() != XFA_ELEMENT_Items) {
       for (CXFA_Node* pTemplateChild =
                pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
            pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
         if (XFA_NeedGenerateForm(pTemplateChild)) {
           XFA_NodeMerge_CloneOrMergeContainer(pDocument, pExistingNode,
                                               pTemplateChild, bRecursive);
         }
       }
     }
-    pExistingNode->SetFlag(XFA_NODEFLAG_Initialized, true);
+    pExistingNode->SetFlag(XFA_NodeFlag_Initialized, true);
     return pExistingNode;
   }
   CXFA_Node* pNewNode = pTemplateNode->CloneTemplateToForm(FALSE);
   pFormParent->InsertChild(pNewNode, NULL);
   if (bRecursive) {
     for (CXFA_Node* pTemplateChild =
              pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
          pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                              XFA_NODEITEM_NextSibling)) {
       if (XFA_NeedGenerateForm(pTemplateChild)) {
@@ skipping 32 matching lines @@
       if (dwNameHash != pNode->GetNameHash()) {
         break;
       }
       CXFA_Node* pNextNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
       pFormParent->RemoveChild(pNode);
       subforms.Add(pNode);
       pNode = pNextNode;
     }
     pFormParent->RemoveChild(pExistingNode);
     pFormParent->InsertChild(pExistingNode);
-    pExistingNode->ClearFlag(XFA_NODEFLAG_UnusedNode);
+    pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
     pExistingNode->SetTemplateNode(pTemplateNode);
     return pExistingNode;
   }
   CXFA_Node* pNewNode = pDocument->GetParser()->GetFactory()->CreateNode(
       XFA_XDPPACKET_Form, XFA_ELEMENT_InstanceManager);
   ASSERT(pNewNode);
   wsInstMgrNodeName =
       FX_WSTRC(L"_") + pTemplateNode->GetCData(XFA_ATTRIBUTE_Name);
   pNewNode->SetCData(XFA_ATTRIBUTE_Name, wsInstMgrNodeName);
   pFormParent->InsertChild(pNewNode, NULL);
@@ skipping 173 matching lines @@
             : NULL;
     if (CXFA_Node* pOccurTemplateNode =
             pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Occur)) {
       pOccurNode = pInstMgrNode
                        ? XFA_NodeMerge_CloneOrMergeContainer(
                              pDocument, pInstMgrNode, pOccurTemplateNode, FALSE)
                        : pOccurTemplateNode;
     } else if (pInstMgrNode) {
       pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_ELEMENT_Occur);
       if (pOccurNode) {
-        pOccurNode->ClearFlag(XFA_NODEFLAG_UnusedNode);
+        pOccurNode->ClearFlag(XFA_NodeFlag_UnusedNode);
       }
     }
     if (pInstMgrNode) {
-      pInstMgrNode->SetFlag(XFA_NODEFLAG_Initialized, true);
+      pInstMgrNode->SetFlag(XFA_NodeFlag_Initialized, true);
       pSearchArray = &subformArray;
       if (pFormParentNode->GetClassID() == XFA_ELEMENT_PageArea) {
         bOneInstance = TRUE;
         if (subformArray.GetSize() < 1) {
           pSearchArray = NULL;
         }
       } else if ((pTemplateNode->GetNameHash() == 0) &&
                  (subformArray.GetSize() < 1)) {
         pSearchArray = NULL;
       }
@@ skipping 43 matching lines @@
         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 (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubform,
                                                 pTemplateChild, TRUE);
-          } else if (pTemplateChild->GetObjectType() ==
-                     XFA_OBJECTTYPE_ContainerNode) {
+          } else if (pTemplateChild->IsContainerNode()) {
             pDocument->DataMerge_CopyContainer(pTemplateChild, pSubform,
                                                pDataNode, FALSE, TRUE, FALSE);
           }
         }
       }
       subformMapArray.RemoveAll();
     }
     for (; iMax < 0 || iCurRepeatIndex < iMax; iCurRepeatIndex++) {
       FX_BOOL bSelfMatch = FALSE;
       XFA_ATTRIBUTEENUM eBindMatch = XFA_ATTRIBUTEENUM_None;
@@ skipping 16 matching lines @@
         }
         CFX_ArrayTemplate<XFA_DataMerge_RecurseRecord> rgItemMatchList;
         CFX_ArrayTemplate<CXFA_Node*> rgItemUnmatchList;
         for (CXFA_Node* pTemplateChild =
                  pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
           if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
                                                 pTemplateChild, TRUE);
-          } else if (pTemplateChild->GetObjectType() ==
-                     XFA_OBJECTTYPE_ContainerNode) {
+          } else if (pTemplateChild->IsContainerNode()) {
             bSelfMatch = FALSE;
             eBindMatch = XFA_ATTRIBUTEENUM_None;
             CXFA_Node* pDataMatch;
             if (eRelation != XFA_ATTRIBUTEENUM_Ordered &&
                 (pDataMatch = XFA_DataMerge_FindMatchingDataNode(
                      pDocument, pTemplateChild, pDataScope, bAccessedDataDOM,
                      FALSE, NULL, bSelfMatch, eBindMatch)) != nullptr) {
               XFA_DataMerge_RecurseRecord sNewRecord = {pTemplateChild,
                                                         pDataMatch};
               if (bSelfMatch) {
@@ skipping 39 matching lines @@
         if (!pFirstInstance) {
           pFirstInstance = pSubformSetNode;
         }
         for (CXFA_Node* pTemplateChild =
                  pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
           if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
                                                 pTemplateChild, TRUE);
-          } else if (pTemplateChild->GetObjectType() ==
-                     XFA_OBJECTTYPE_ContainerNode) {
+          } else if (pTemplateChild->IsContainerNode()) {
             pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode,
                                                pDataScope);
           }
         }
       }
     }
     if (iCurRepeatIndex == 0 && bAccessedDataDOM == FALSE) {
       int32_t iLimit = iMax;
       if (pInstMgrNode && pTemplateNode->GetNameHash() == 0) {
         iLimit = subformArray.GetSize();
@@ skipping 20 matching lines @@
         if (!pFirstInstance) {
           pFirstInstance = pSubformNode;
         }
         for (CXFA_Node* pTemplateChild =
                  pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
           if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
             XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformNode,
                                                 pTemplateChild, TRUE);
-          } else if (pTemplateChild->GetObjectType() ==
-                     XFA_OBJECTTYPE_ContainerNode) {
+          } else if (pTemplateChild->IsContainerNode()) {
             pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformNode,
                                                pDataScope);
           }
         }
       }
     }
   }
   int32_t iMinimalLimit = iCurRepeatIndex == 0 ? iInit : iMin;
   for (; iCurRepeatIndex < iMinimalLimit; iCurRepeatIndex++) {
     CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
         pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
     ASSERT(pSubformSetNode);
     if (!pFirstInstance) {
       pFirstInstance = pSubformSetNode;
     }
     FX_BOOL bFound = FALSE;
     for (CXFA_Node* pTemplateChild =
              pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
          pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                              XFA_NODEITEM_NextSibling)) {
       if (XFA_NeedGenerateForm(pTemplateChild, bUseInstanceManager)) {
         XFA_NodeMerge_CloneOrMergeContainer(pDocument, pSubformSetNode,
                                             pTemplateChild, TRUE);
-      } else if (pTemplateChild->GetObjectType() ==
-                 XFA_OBJECTTYPE_ContainerNode) {
+      } else if (pTemplateChild->IsContainerNode()) {
         if (bFound && eRelation == XFA_ATTRIBUTEENUM_Choice) {
           continue;
         }
         pDocument->DataMerge_CopyContainer(pTemplateChild, pSubformSetNode,
                                            pDataScope, FALSE, bDataMerge);
         bFound = TRUE;
       }
     }
   }
   return pFirstInstance;
@@ skipping 177 matching lines @@
     }
   }
   if (bMatchRef &&
       (eClassID == XFA_ELEMENT_Subform || eClassID == XFA_ELEMENT_SubformSet ||
        eClassID == XFA_ELEMENT_Area || eClassID == XFA_ELEMENT_PageArea ||
        eClassID == XFA_ELEMENT_PageSet)) {
     for (CXFA_Node* pFormChild =
              pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
          pFormChild;
          pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      if (pFormChild->GetObjectType() != XFA_OBJECTTYPE_ContainerNode) {
+      if (!pFormChild->IsContainerNode())
         continue;
-      }
-      if (pFormChild->HasFlag(XFA_NODEFLAG_UnusedNode)) {
+      if (pFormChild->IsUnusedNode())
         continue;
-      }
+
       XFA_DataMerge_UpdateBindingRelations(pDocument, pFormChild,
                                            pDataNode ? pDataNode : pDataScope,
                                            bDataRef, bParentDataRef);
     }
   }
 }
 CXFA_Node* XFA_DataMerge_FindDataScope(CXFA_Node* pParentFormNode) {
   for (CXFA_Node* pRootBoundNode = pParentFormNode;
-       pRootBoundNode &&
-       pRootBoundNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode;
+       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));
 }
 void CXFA_Document::DataMerge_UpdateBindingRelations(
@@ skipping 89 matching lines @@
     bEmptyForm = TRUE;
     pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form);
     ASSERT(pFormRoot);
     pFormRoot->SetCData(XFA_ATTRIBUTE_Name, L"form");
     m_pRootNode->InsertChild(pFormRoot, NULL);
   } 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);
+      pNode->SetFlag(XFA_NodeFlag_UnusedNode, true);
     }
   }
   CXFA_Node* pSubformSetNode = XFA_NodeMerge_CloneOrMergeContainer(
       this, pFormRoot, pTemplateChosen, FALSE);
   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);
   XFA_DataMerge_CreateDataBinding(pSubformSetNode, pDataTopLevel);
   for (CXFA_Node* pTemplateChild =
            pTemplateChosen->GetNodeItem(XFA_NODEITEM_FirstChild);
        pTemplateChild;
        pTemplateChild = pTemplateChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (XFA_NeedGenerateForm(pTemplateChild)) {
       XFA_NodeMerge_CloneOrMergeContainer(this, pSubformSetNode, pTemplateChild,
                                           TRUE);
-    } else if (pTemplateChild->GetObjectType() ==
-               XFA_OBJECTTYPE_ContainerNode) {
+    } else if (pTemplateChild->IsContainerNode()) {
       DataMerge_CopyContainer(pTemplateChild, pSubformSetNode, pDataTopLevel);
     }
   }
   if (pDDRoot) {
     XFA_DataDescription_UpdateDataRelation(pDataRoot, pDDRoot);
   }
   DataMerge_UpdateBindingRelations(pSubformSetNode);
   CXFA_Node* pPageSetNode =
       pSubformSetNode->GetFirstChildByClass(XFA_ELEMENT_PageSet);
   while (pPageSetNode) {
     m_pPendingPageSet.Add(pPageSetNode);
     CXFA_Node* pNextPageSetNode =
         pPageSetNode->GetNextSameClassSibling(XFA_ELEMENT_PageSet);
     pSubformSetNode->RemoveChild(pPageSetNode);
     pPageSetNode = pNextPageSetNode;
   }
   if (!bEmptyForm) {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
         sIterator(pFormRoot);
     CXFA_Node* pNode = sIterator.MoveToNext();
     while (pNode) {
-      if (pNode->HasFlag(XFA_NODEFLAG_UnusedNode)) {
-        if (pNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode ||
+      if (pNode->IsUnusedNode()) {
+        if (pNode->IsContainerNode() ||
             pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
           CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext();
           pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode);
           pNode = pNext;
         } else {
-          pNode->ClearFlag(XFA_NODEFLAG_UnusedNode);
-          pNode->SetFlag(XFA_NODEFLAG_Initialized, true);
+          pNode->ClearFlag(XFA_NodeFlag_UnusedNode);
+          pNode->SetFlag(XFA_NodeFlag_Initialized, true);
           pNode = sIterator.MoveToNext();
         }
       } else {
-        pNode->SetFlag(XFA_NODEFLAG_Initialized, true);
+        pNode->SetFlag(XFA_NodeFlag_Initialized, true);
         pNode = sIterator.MoveToNext();
       }
     }
   }
 }
 void CXFA_Document::DoDataRemerge(FX_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, NULL);
   }
   XFA_DataMerge_ClearGlobalBinding(this);
   if (bDoDataMerge) {
     DoDataMerge();
   }
   CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor();
   pLayoutProcessor->SetForceReLayout(TRUE);
 }