Split the XFA_OBJECTTYPE enum into two parts.

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>
 
@@ skipping 25 matching lines @@
 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);
+XFA_ObjectType XFA_GetElementObjectType(XFA_ELEMENT eElement) {
+  return 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) {}
+CXFA_Object::CXFA_Object(CXFA_Document* pDocument, XFA_ObjectType type)
+    : m_pDocument(pDocument), m_objectType(type) {}
 
 CXFA_Object::~CXFA_Object() {}
 
 void CXFA_Object::GetClassName(CFX_WideStringC& wsName) const {
   wsName = XFA_GetElementByID(GetClassID())->pName;
 }
 
 uint32_t CXFA_Object::GetClassHashCode() const {
   return XFA_GetElementByID(GetClassID())->uHash;
 }
@@ skipping 46 matching lines @@
                      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_uNodeFlags(XFA_NodeFlag_None),
       m_dwNameHash(0),
       m_pAuxNode(nullptr),
       m_pMapModuleData(nullptr) {
   ASSERT(m_pDocument);
 }
 
 CXFA_Node::~CXFA_Node() {
   ASSERT(!m_pParent);
   RemoveMapModuleKey();
   CXFA_Node* pNode = m_pChild;
   while (pNode) {
     CXFA_Node* pNext = pNode->m_pNext;
     pNode->m_pParent = nullptr;
     delete pNode;
     pNode = pNext;
   }
-  if (m_pXMLNode && HasFlag(XFA_NODEFLAG_OwnXMLNode))
+  if (m_pXMLNode && IsOwnXMLNode())
     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 nullptr;
 
   MergeAllData(pClone);
   pClone->UpdateNameHash();
   if (IsNeedSavingXMLNode()) {
     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 = nullptr;
       pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       pCloneXML = m_pXMLNode->Clone(FALSE);
     }
     pClone->SetXMLMappingNode(pCloneXML);
-    pClone->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
+    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->SetFlag(XFA_NodeFlag_Initialized, true);
   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;
@@ skipping 10 matching lines @@
         return pPrev;
       }
       return nullptr;
     default:
       break;
   }
   return nullptr;
 }
 
 CXFA_Node* CXFA_Node::GetNodeItem(XFA_NODEITEM eItem,
-                                  XFA_OBJECTTYPE eType) const {
+                                  XFA_ObjectType eType) const {
   CXFA_Node* pNode = nullptr;
   switch (eItem) {
     case XFA_NODEITEM_NextSibling:
       pNode = m_pNext;
-      if (eType != XFA_OBJECTTYPEMASK) {
-        while (pNode && pNode->GetObjectType() != eType)
-          pNode = pNode->m_pNext;
-      }
+      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)
-          pNode = pNode->m_pNext;
-      }
+      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)
-          pNode = pNode->m_pParent;
-      }
+      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()) {
+          if (eType == pSibling->GetObjectType())
             pNode = pSibling;
-          }
+
           pSibling = pSibling->m_pNext;
         }
       }
       break;
     default:
       break;
   }
   return pNode;
 }
 
@@ skipping 58 matching lines @@
         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)
             break;
           InsertChild(pNewNode, nullptr);
-          pNewNode->SetFlag(XFA_NODEFLAG_Initialized, true);
+          pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
           nodes.Add(pNewNode);
           break;
         }
       }
     }
   }
   return nodes.GetSize();
 }
 
 CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_ELEMENT eElement,
@@ skipping 13 matching lines @@
 
   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);
+  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) {
+  if (BindsFormItems()) {
     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)
     formItems.Add(pFormNode);
   return formItems.GetSize();
 }
 
 int32_t CXFA_Node::AddBindItem(CXFA_Node* pFormNode) {
   ASSERT(pFormNode);
-  if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
+  if (BindsFormItems()) {
     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;
+  m_uNodeFlags |= XFA_NodeFlag_BindFormItems;
   return 2;
 }
 
 int32_t CXFA_Node::RemoveBindItem(CXFA_Node* pFormNode) {
-  if (m_uFlags & XFA_NODEFLAG_BindFormItems) {
+  if (BindsFormItems()) {
     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)
         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;
+        m_uNodeFlags &= ~XFA_NodeFlag_BindFormItems;
       }
       iCount--;
     }
     return iCount;
   }
   CXFA_Node* pOldFormItem =
       static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
   if (pOldFormItem == pFormNode) {
     SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
     pOldFormItem = nullptr;
@@ skipping 35 matching lines @@
       if (!wsPicture.IsEmpty())
         return pFieldWidgetData;
       CXFA_Node* pDataNode = GetBindData();
       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->HasRemovedChildren())
           continue;
         pFieldWidgetData = pFormNode->GetWidgetData();
         if (pFieldWidgetData) {
           pFieldWidgetData->GetPictureContent(wsPicture,
                                               XFA_VALUEPICTURE_DataBind);
         }
         if (!wsPicture.IsEmpty())
           break;
         pFieldWidgetData = nullptr;
       }
@@ skipping 50 matching lines @@
 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);
+        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) &&
               (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
                eValue == XFA_ATTRIBUTEENUM_PageArea)) {
             return XFA_ATTRIBUTEENUM_ContentArea;
           }
           CXFA_Node* pNode =
@@ skipping 440 matching lines @@
   pFakeRoot = pParser->GetRootNode();
   if (pFakeRoot) {
     if (bOverwrite) {
       CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild);
       CXFA_Node* pNewChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
       int32_t index = 0;
       while (pNewChild) {
         CXFA_Node* pItem = pNewChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         pFakeRoot->RemoveChild(pNewChild);
         InsertChild(index++, pNewChild);
-        pNewChild->SetFlag(XFA_NODEFLAG_Initialized, true);
+        pNewChild->SetFlag(XFA_NodeFlag_Initialized, true);
         pNewChild = pItem;
       }
       while (pChild) {
         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);
+        SetFlag(XFA_NodeFlag_OwnXMLNode, false);
         if (pTempXMLNode && !pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent)) {
           pFakeXMLRoot = pTempXMLNode;
         } else {
           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->SetFlag(XFA_NodeFlag_Initialized, true);
         pChild = pItem;
       }
     }
     if (pFakeXMLRoot) {
       pFakeRoot->SetXMLMappingNode(pFakeXMLRoot);
-      pFakeRoot->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
+      pFakeRoot->SetFlag(XFA_NodeFlag_OwnXMLNode, false);
     }
-    pFakeRoot->SetFlag(XFA_NODEFLAG_HasRemoved, false);
+    pFakeRoot->SetFlag(XFA_NodeFlag_HasRemovedChildren, false);
   } else {
     if (pFakeXMLRoot) {
       pFakeXMLRoot->Release();
       pFakeXMLRoot = nullptr;
     }
   }
 }
 
 void CXFA_Node::Script_NodeClass_SaveFilteredXML(CFXJSE_Arguments* pArguments) {
   // TODO(weili): Check whether we need to implement this, pdfium:501.
@@ skipping 562 matching lines @@
       wsNewValue = pValue->ToWideString();
 
     CFX_WideString wsFormatValue(wsNewValue);
     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)) {
+        if (!pFormNode || pFormNode->HasRemovedChildren()) {
           continue;
         }
         pContainerWidgetData = pFormNode->GetContainerWidgetData();
         if (pContainerWidgetData) {
           pContainerWidgetData->GetPictureContent(wsPicture,
                                                   XFA_VALUEPICTURE_DataBind);
         }
         if (!wsPicture.IsEmpty()) {
           break;
         }
@@ skipping 1333 matching lines @@
   }
 }
 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 = nullptr;
   for (CXFA_Node* pRootBoundNode = pFormParent;
-       pRootBoundNode &&
-       pRootBoundNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode;
+       pRootBoundNode && pRootBoundNode->IsContainerNode();
        pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
     pDataScope = pRootBoundNode->GetBindData();
     if (pDataScope) {
       break;
     }
   }
   if (!pDataScope) {
     pDataScope = ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
     ASSERT(pDataScope);
   }
@@ skipping 1058 matching lines @@
   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 = nullptr;
   CXFA_Node* pBindNode = nullptr;
   switch (GetObjectType()) {
-    case XFA_OBJECTTYPE_ContainerNode: {
+    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();
         if (bSyncData && pBind) {
           CFX_WideStringArray wsSaveTextArray;
@@ skipping 80 matching lines @@
         for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
           if (nodeArray[i] != this) {
             nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, true,
                                            FALSE);
           }
         }
       }
       pBindNode = nullptr;
       break;
     }
-    case XFA_OBJECTTYPE_ContentNode: {
+    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());
         }
       }
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         pContentRawDataNode = CreateSamePacketNode(
             (wsContentType == FX_WSTRC(L"text/xml")) ? XFA_ELEMENT_Sharpxml
                                                      : XFA_ELEMENT_Sharptext);
         InsertChild(pContentRawDataNode);
       }
       return pContentRawDataNode->SetScriptContent(
           wsContent, wsXMLValue, bNotify, bScriptModify, bSyncData);
     } break;
-    case XFA_OBJECTTYPE_NodeC:
-    case XFA_OBJECTTYPE_TextNode:
+    case XFA_ObjectType::NodeC:
+    case XFA_ObjectType::TextNode:
       pNode = this;
       break;
-    case XFA_OBJECTTYPE_NodeV:
+    case XFA_ObjectType::NodeV:
       pNode = this;
       if (bSyncData && GetPacketID() == XFA_XDPPACKET_Form) {
         CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParent) {
           pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
         }
         if (pParent && pParent->GetClassID() == XFA_ELEMENT_Value) {
           pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
           if (pParent && pParent->IsContainerNode()) {
             pBindNode = pParent->GetBindData();
@@ skipping 39 matching lines @@
   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 = nullptr;
   switch (GetObjectType()) {
-    case XFA_OBJECTTYPE_ContainerNode:
+    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);
         if (pChildValue && XFA_FieldIsMultiListBox(this)) {
           pChildValue->SetAttribute(XFA_ATTRIBUTE_ContentType,
                                     FX_WSTRC(L"text/xml"));
         }
         return pChildValue
                    ? pChildValue->TryContent(wsContent, bScriptModify, bProto)
                    : FALSE;
       }
       break;
-    case XFA_OBJECTTYPE_ContentNode: {
+    case XFA_ObjectType::ContentNode: {
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
         if (GetClassID() == XFA_ELEMENT_ExData) {
           CFX_WideString wsContentType;
           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 = CreateSamePacketNode(element);
         InsertChild(pContentRawDataNode);
       }
       return pContentRawDataNode->TryContent(wsContent, bScriptModify, bProto);
     }
-    case XFA_OBJECTTYPE_NodeC:
-    case XFA_OBJECTTYPE_NodeV:
-    case XFA_OBJECTTYPE_TextNode:
+    case XFA_ObjectType::NodeC:
+    case XFA_ObjectType::NodeV:
+    case XFA_ObjectType::TextNode:
       pNode = this;
     default:
       if (GetClassID() == XFA_ELEMENT_DataValue) {
         pNode = this;
       }
       break;
   }
   if (pNode) {
     if (bScriptModify) {
       CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
@@ skipping 24 matching lines @@
     case XFA_XDPPACKET_SourceSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet));
     case XFA_XDPPACKET_Xdc:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
     default:
       return this;
   }
 }
 FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
   wsNamespace.clear();
-  if (GetObjectType() == XFA_OBJECTTYPE_ModelNode ||
-      GetClassID() == XFA_ELEMENT_Packet) {
+  if (IsModelNode() || GetClassID() == XFA_ELEMENT_Packet) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return FALSE;
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode) {
       return FALSE;
@@ skipping 47 matching lines @@
     }
   }
   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 nullptr;
     InsertChild(pNewNode, nullptr);
-    pNewNode->SetFlag(XFA_NODEFLAG_Initialized, true);
+    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) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
@@ skipping 57 matching lines @@
     }
     pNode->m_pNext = pPrev->m_pNext;
     pPrev->m_pNext = pNode;
     index = iCount;
   }
   if (!pNode->m_pNext) {
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
   ASSERT(!m_pLastChild->m_pNext);
-  pNode->ClearFlag(XFA_NODEFLAG_HasRemoved);
+  pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren);
   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));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index);
-    pNode->ClearFlag(XFA_NODEFLAG_OwnXMLNode);
+    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;
   }
@@ skipping 18 matching lines @@
       nIndex++;
     }
     pNode->m_pNext = pPrev->m_pNext;
     pPrev->m_pNext = pNode;
   }
   if (!pNode->m_pNext) {
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
   ASSERT(!m_pLastChild->m_pNext);
-  pNode->ClearFlag(XFA_NODEFLAG_HasRemoved);
+  pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren);
   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));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex);
-    pNode->ClearFlag(XFA_NODEFLAG_OwnXMLNode);
+    pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode);
   }
   return TRUE;
 }
 CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling() {
   if (!m_pParent) {
     return nullptr;
   }
   for (CXFA_Node* pSibling = m_pParent->m_pChild; pSibling;
        pSibling = pSibling->m_pNext) {
     if (pSibling->m_pNext == this) {
@@ skipping 18 matching lines @@
     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 = nullptr;
     pNode->m_pParent = nullptr;
   }
   ASSERT(!m_pLastChild || !m_pLastChild->m_pNext);
   OnRemoved(bNotify);
-  pNode->SetFlag(XFA_NODEFLAG_HasRemoved, true);
+  pNode->SetFlag(XFA_NodeFlag_HasRemovedChildren, 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);
         CFX_WideStringC wsAttributeName =
             pNode->GetCData(XFA_ATTRIBUTE_QualifiedName);
         pXMLElement->RemoveAttribute(wsAttributeName.c_str());
       }
       CFX_WideString wsName;
       pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
       CFDE_XMLElement* pNewXMLElement = new CFDE_XMLElement(wsName);
       CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pNewXMLElement->SetTextData(CFX_WideString(wsValue));
       }
       pNode->m_pXMLNode = pNewXMLElement;
       pNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       m_pXMLNode->RemoveChildNode(pNode->m_pXMLNode);
     }
-    pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
+    pNode->SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
   return TRUE;
 }
 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) {
@@ skipping 77 matching lines @@
         }
         break;
       }
     }
   }
   return pInstanceMgr;
 }
 CXFA_Node* CXFA_Node::GetOccurNode() {
   return GetFirstChildByClass(XFA_ELEMENT_Occur);
 }
-FX_BOOL CXFA_Node::HasFlag(uint32_t dwFlag) const {
-  if (m_uFlags & dwFlag) {
-    return TRUE;
-  }
-  switch (dwFlag) {
-    case XFA_NODEFLAG_HasRemoved:
-      return m_pParent && m_pParent->HasFlag(dwFlag);
-    default:
-      break;
-  }
-  return FALSE;
+bool CXFA_Node::HasFlag(XFA_NodeFlag dwFlag) const {
+  if (m_uNodeFlags & dwFlag)
+    return true;
+  if (dwFlag == XFA_NodeFlag_HasRemovedChildren)
+    return m_pParent && m_pParent->HasFlag(dwFlag);
+  return false;
 }
 
 void CXFA_Node::SetFlag(uint32_t dwFlag, bool bNotify) {
-  if (dwFlag == XFA_NODEFLAG_Initialized && bNotify &&
-      !HasFlag(XFA_NODEFLAG_Initialized)) {
+  if (dwFlag == XFA_NodeFlag_Initialized && bNotify && !IsInitialized()) {
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (pNotify) {
       pNotify->OnNodeReady(this);
     }
   }
-  m_uFlags |= dwFlag;
+  m_uNodeFlags |= dwFlag;
 }
 
 void CXFA_Node::ClearFlag(uint32_t dwFlag) {
-  m_uFlags &= ~dwFlag;
+  m_uNodeFlags &= ~dwFlag;
 }
 
 FX_BOOL CXFA_Node::IsAttributeInXML() {
   return GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData;
 }
 
 void CXFA_Node::OnRemoved(bool bNotify) {
   if (!bNotify)
     return;
 
   CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (pNotify)
     pNotify->OnChildRemoved();
 }
 
 void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr, bool bNotify) {
-  if (bNotify && HasFlag(XFA_NODEFLAG_Initialized)) {
+  if (bNotify && IsInitialized()) {
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (pNotify) {
       pNotify->OnValueChanging(this, eAttr);
     }
   }
 }
 
 void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr,
                           bool bNotify,
                           FX_BOOL bScriptModify) {
-  if (bNotify && HasFlag(XFA_NODEFLAG_Initialized)) {
+  if (bNotify && IsInitialized()) {
     Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify);
   }
 }
 
 int32_t CXFA_Node::execSingleEventByName(const CFX_WideStringC& wsEventName,
                                          XFA_ELEMENT eElementType) {
   int32_t iRet = XFA_EVENTERROR_NotExist;
   const XFA_ExecEventParaInfo* eventParaInfo =
       GetEventParaInfoByName(wsEventName);
   if (eventParaInfo) {
@@ skipping 60 matching lines @@
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
     wsName = XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   }
 }
 CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideString wsTag(GetCData(XFA_ATTRIBUTE_Name));
     m_pXMLNode = new CFDE_XMLElement(wsTag);
-    SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
+    SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
   return m_pXMLNode;
 }
 FX_BOOL CXFA_Node::IsNeedSavingXMLNode() {
   return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets ||
                         GetClassID() == XFA_ELEMENT_Xfa);
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::CreateMapModuleData() {
   if (!m_pMapModuleData)
@@ skipping 211 matching lines @@
   }
   if (bNeedMove) {
     void* pBufferBlockData = pSrcModuleData->m_BufferMap.GetValueAt(pKey);
     if (pBufferBlockData) {
       pSrcModuleData->m_BufferMap.RemoveKey(pKey);
       pDstModuleData->m_BufferMap.RemoveKey(pKey);
       pDstModuleData->m_BufferMap.SetAt(pKey,
                                         (XFA_MAPDATABLOCK*)pBufferBlockData);
     }
   }
-  if (pDstModule->GetObjectType() == XFA_OBJECTTYPE_NodeV) {
+  if (pDstModule->IsNodeV()) {
     CFX_WideString wsValue = pDstModule->GetScriptContent(FALSE);
     CFX_WideString wsFormatValue(wsValue);
     CXFA_WidgetData* pWidgetData = pDstModule->GetContainerWidgetData();
     if (pWidgetData) {
       pWidgetData->GetFormatDataValue(wsValue, wsFormatValue);
     }
     pDstModule->SetScriptContent(wsValue, wsFormatValue, true, TRUE);
   }
 }
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pSrcModule,
@@ skipping 10 matching lines @@
          pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling),
          pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE);
     }
   }
   pSrcModule->MoveBufferMapData(pDstModule, pKey);
 }
 
 CXFA_OrdinaryObject::CXFA_OrdinaryObject(CXFA_Document* pDocument,
                                          XFA_ELEMENT eElement)
-    : CXFA_Object(pDocument, XFA_OBJECTTYPE_OrdinaryObject), m_uScriptHash(0) {
+    : CXFA_Object(pDocument, XFA_ObjectType::OrdinaryObject), m_uScriptHash(0) {
   m_eNodeClass = eElement;
 }
 
 CXFA_OrdinaryObject::~CXFA_OrdinaryObject() {}
 
 XFA_ELEMENT CXFA_OrdinaryObject::GetClassID() const {
   return m_eNodeClass;
 }
 
 uint32_t CXFA_OrdinaryObject::GetScriptObjHash() const {
   return m_uScriptHash;
 }
 
 CXFA_ThisProxy::CXFA_ThisProxy(CXFA_Node* pThisNode, CXFA_Node* pScriptNode)
-    : CXFA_Object(pThisNode->GetDocument(), XFA_OBJECTTYPE_VariablesThis),
+    : CXFA_Object(pThisNode->GetDocument(), XFA_ObjectType::VariablesThis),
       m_pThisNode(NULL),
       m_pScriptNode(NULL) {
   m_pThisNode = pThisNode;
   m_pScriptNode = pScriptNode;
 }
 
 CXFA_ThisProxy::~CXFA_ThisProxy() {}
 
 CXFA_Node* CXFA_ThisProxy::GetThisNode() const {
   return m_pThisNode;
 }
 
 CXFA_Node* CXFA_ThisProxy::GetScriptNode() const {
   return m_pScriptNode;
 }
 
 CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument)
-    : CXFA_Object(pDocument, XFA_OBJECTTYPE_NodeList) {
+    : CXFA_Object(pDocument, XFA_ObjectType::NodeList) {
   m_pDocument->GetScriptContext()->AddToCacheList(
       std::unique_ptr<CXFA_NodeList>(this));
 }
 CXFA_NodeList::~CXFA_NodeList() {}
 XFA_ELEMENT CXFA_NodeList::GetClassID() const {
   return XFA_ELEMENT_NodeList;
 }
 CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) {
   uint32_t dwHashCode = FX_HashCode_GetW(wsName, false);
   int32_t iCount = GetLength();
@@ skipping 157 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);
 }