Split the XFA_OBJECTTYPE enum into two parts.

xfa/fxfa/parser/xfa_parser_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_parser_imp.h"
 
 #include <memory>
 
@@ skipping 160 matching lines @@
           CFDE_XMLElement* child = static_cast<CFDE_XMLElement*>(pXMLChild);
           child->GetLocalTagName(wsNodeStr);
           pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
           CFX_WideString wsChildValue;
           XFA_GetPlainTextFromRichText(child, wsChildValue);
           if (!wsChildValue.IsEmpty())
             pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsChildValue);
 
           pXFANode->InsertChild(pXFAChild);
           pXFAChild->SetXMLMappingNode(pXMLChild);
-          pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
+          pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
           break;
         }
       }
       m_pRootNode = pXFANode;
     } else {
       m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE);
     }
-  } else if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
+  } else if (pXFANode->IsContentNode()) {
     ParseContentNode(pXFANode, pXMLNode, ePacketID);
     m_pRootNode = pXFANode;
   } else {
     m_pRootNode = NormalLoader(pXFANode, pXMLNode, ePacketID);
   }
 }
 
 CXFA_Document* CXFA_SimpleParser::GetFactory() const {
   return m_pFactory;
 }
@@ skipping 498 matching lines @@
       return NULL;
     }
     CFX_WideString wsLocalName;
     static_cast<CFDE_XMLElement*>(pDataXMLNode)->GetLocalTagName(wsLocalName);
     pNode->SetCData(XFA_ATTRIBUTE_Name, wsLocalName);
     if (!DataLoader(pNode, pDataXMLNode, TRUE)) {
       return NULL;
     }
     pNode->SetXMLMappingNode(pDataXMLNode);
     if (pDataXMLNode != pXMLDocumentNode) {
-      pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
+      pNode->SetFlag(XFA_NodeFlag_OwnXMLNode, false);
     }
     return pNode;
   }
   return NULL;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = NULL;
   if (ePacketID == XFA_XDPPACKET_LocaleSet) {
@@ skipping 165 matching lines @@
         if (pElemInfo->eName == XFA_ELEMENT_Validate ||
             pElemInfo->eName == XFA_ELEMENT_Locale) {
           if (ePacketID == XFA_XDPPACKET_Config) {
             ParseContentNode(pXFAChild, pXMLElement, ePacketID);
           } else {
             NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute);
           }
           break;
         }
         switch (pXFAChild->GetObjectType()) {
-          case XFA_OBJECTTYPE_ContentNode:
-          case XFA_OBJECTTYPE_TextNode:
-          case XFA_OBJECTTYPE_NodeC:
-          case XFA_OBJECTTYPE_NodeV:
+          case XFA_ObjectType::ContentNode:
+          case XFA_ObjectType::TextNode:
+          case XFA_ObjectType::NodeC:
+          case XFA_ObjectType::NodeV:
             if (IsNeedValue) {
               ParseContentNode(pXFAChild, pXMLElement, ePacketID);
             }
             break;
           default:
             NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute);
             break;
         }
       } break;
       case FDE_XMLNODE_Instruction:
@@ skipping 108 matching lines @@
       if (eNodeType == FDE_XMLNODE_Element)
         break;
       if (eNodeType == FDE_XMLNODE_Text)
         static_cast<CFDE_XMLText*>(pXMLChild)->GetText(wsValue);
       else if (eNodeType == FDE_XMLNODE_CharData)
         static_cast<CFDE_XMLCharData*>(pXMLChild)->GetCharData(wsValue);
     }
     break;
   }
   if (!wsValue.IsEmpty()) {
-    if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
+    if (pXFANode->IsContentNode()) {
       CXFA_Node* pContentRawDataNode =
           m_pFactory->CreateNode(ePacketID, element);
       ASSERT(pContentRawDataNode);
       pContentRawDataNode->SetCData(XFA_ATTRIBUTE_Value, wsValue);
       pXFANode->InsertChild(pContentRawDataNode);
     } else {
       pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsValue);
     }
   }
 }
@@ skipping 112 matching lines @@
               return;
             }
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_Name, wsAttrName);
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_QualifiedName,
                                    wsAttrQualifiedName);
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_Value, wsAttrValue);
             pXFAMetaData->SetEnum(XFA_ATTRIBUTE_Contains,
                                   XFA_ATTRIBUTEENUM_MetaData);
             pXFAChild->InsertChild(pXFAMetaData);
             pXFAMetaData->SetXMLMappingNode(pXMLElement);
-            pXFAMetaData->SetFlag(XFA_NODEFLAG_Initialized, false);
+            pXFAMetaData->SetFlag(XFA_NodeFlag_Initialized, false);
           }
           if (!bNeedValue) {
             CFX_WideString wsNilName(L"xsi:nil");
             pXMLElement->RemoveAttribute(wsNilName.c_str());
           }
         }
         pXFANode->InsertChild(pXFAChild);
         if (eNodeType == XFA_ELEMENT_DataGroup) {
           ParseDataGroup(pXFAChild, pXMLElement, ePacketID);
         } else {
           if (bNeedValue) {
             ParseDataValue(pXFAChild, pXMLChild, XFA_XDPPACKET_Datasets);
           }
         }
         pXFAChild->SetXMLMappingNode(pXMLElement);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
+        pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
       }
         continue;
       case FDE_XMLNODE_CharData: {
         CFDE_XMLCharData* pXMLCharData =
             static_cast<CFDE_XMLCharData*>(pXMLChild);
         CFX_WideString wsCharData;
         pXMLCharData->GetCharData(wsCharData);
         if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) {
           continue;
         }
         CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
                                                       XFA_ELEMENT_DataValue);
         if (pXFAChild == NULL) {
           return;
         }
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCharData);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLCharData);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
+        pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
       }
         continue;
       case FDE_XMLNODE_Text: {
         CFDE_XMLText* pXMLText = static_cast<CFDE_XMLText*>(pXMLChild);
         CFX_WideString wsText;
         pXMLText->GetText(wsText);
         if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) {
           continue;
         }
         CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
                                                       XFA_ELEMENT_DataValue);
         if (pXFAChild == NULL) {
           return;
         }
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsText);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLText);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
+        pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
       }
         continue;
       case FDE_XMLNODE_Instruction:
         continue;
       default:
         continue;
     }
   }
 }
 
@@ skipping 40 matching lines @@
         if (!wsCurValue.IsEmpty()) {
           CXFA_Node* pXFAChild =
               m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
           if (!pXFAChild)
             return;
 
           pXFAChild->SetCData(XFA_ATTRIBUTE_Name, L"");
           pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue);
           pXFANode->InsertChild(pXFAChild);
           pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
-          pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
+          pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
           wsValueTextBuf << wsCurValue;
           wsCurValueTextBuf.Clear();
         }
         pXMLCurValueNode = nullptr;
       }
       CXFA_Node* pXFAChild =
           m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
       if (!pXFAChild)
         return;
 
       CFX_WideString wsNodeStr;
       static_cast<CFDE_XMLElement*>(pXMLChild)->GetLocalTagName(wsNodeStr);
       pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
       ParseDataValue(pXFAChild, pXMLChild, ePacketID);
       pXFANode->InsertChild(pXFAChild);
       pXFAChild->SetXMLMappingNode(pXMLChild);
-      pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
+      pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
       CFX_WideStringC wsCurValue = pXFAChild->GetCData(XFA_ATTRIBUTE_Value);
       wsValueTextBuf << wsCurValue;
     }
   }
   if (pXMLCurValueNode) {
     CFX_WideString wsCurValue = wsCurValueTextBuf.MakeString();
     if (!wsCurValue.IsEmpty()) {
       if (bMarkAsCompound) {
         CXFA_Node* pXFAChild =
             m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
         if (!pXFAChild)
           return;
 
         pXFAChild->SetCData(XFA_ATTRIBUTE_Name, L"");
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
+        pXFAChild->SetFlag(XFA_NodeFlag_Initialized, false);
       }
       wsValueTextBuf << wsCurValue;
       wsCurValueTextBuf.Clear();
     }
     pXMLCurValueNode = nullptr;
   }
   CFX_WideString wsNodeValue = wsValueTextBuf.MakeString();
   pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsNodeValue);
 }
 
@@ skipping 279 matching lines @@
     }
     if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return (m_syntaxParserResult == FDE_XmlSyntaxResult::Error ||
           m_NodeStack.GetSize() != 1)
              ? -1
              : m_pParser->GetStatus();
 }