Convert XFA_ELEMENT to an enum class

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 134 matching lines @@
     m_pStream = NULL;
   }
   pXMLNode = XFA_FDEExtension_GetDocumentNode(m_pXMLDoc);
   return XFA_PARSESTATUS_Done;
 }
 
 void CXFA_SimpleParser::ConstructXFANode(CXFA_Node* pXFANode,
                                          CFDE_XMLNode* pXMLNode) {
   XFA_XDPPACKET ePacketID = (XFA_XDPPACKET)pXFANode->GetPacketID();
   if (ePacketID == XFA_XDPPACKET_Datasets) {
-    if (pXFANode->GetClassID() == XFA_ELEMENT_DataValue) {
+    if (pXFANode->GetClassID() == XFA_Element::DataValue) {
       for (CFDE_XMLNode* pXMLChild =
                pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
            pXMLChild;
            pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
         FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
         if (eNodeType == FDE_XMLNODE_Instruction)
           continue;
 
         if (eNodeType == FDE_XMLNODE_Element) {
           CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
-                                                        XFA_ELEMENT_DataValue);
+                                                        XFA_Element::DataValue);
           if (!pXFAChild)
             return;
 
           CFX_WideString wsNodeStr;
           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())
@@ skipping 203 matching lines @@
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_XDP(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   if (!XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_XDP)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_XDP)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_XDP)->eFlags)) {
     return nullptr;
   }
   CXFA_Node* pXFARootNode =
-      m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Xfa);
+      m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_Element::Xfa);
   if (!pXFARootNode) {
     return nullptr;
   }
   m_pRootNode = pXFARootNode;
   pXFARootNode->SetCData(XFA_ATTRIBUTE_Name, L"xfa");
   {
     CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLDocumentNode);
     int32_t iAttributeCount = pElement->CountAttributes();
     for (int32_t i = 0; i < iAttributeCount; i++) {
       CFX_WideString wsAttriName, wsAttriValue;
@@ skipping 117 matching lines @@
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Config(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   if (!XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Config)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_Config)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_Config)->eFlags)) {
     return NULL;
   }
   CXFA_Node* pNode =
-      m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_ELEMENT_Config);
+      m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_Element::Config);
   if (!pNode) {
     return NULL;
   }
   pNode->SetCData(XFA_ATTRIBUTE_Name,
                   XFA_GetPacketByIndex(XFA_PACKET_Config)->pName);
   if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
     return NULL;
   }
   pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_TemplateForm(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = NULL;
   if (ePacketID == XFA_XDPPACKET_Template) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Template)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_Template)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_Template)->eFlags)) {
       pNode =
-          m_pFactory->CreateNode(XFA_XDPPACKET_Template, XFA_ELEMENT_Template);
+          m_pFactory->CreateNode(XFA_XDPPACKET_Template, XFA_Element::Template);
       if (!pNode) {
         return NULL;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_Template)->pName);
       if (m_bDocumentParser) {
         CFX_WideString wsNamespaceURI;
         CFDE_XMLElement* pXMLDocumentElement =
             static_cast<CFDE_XMLElement*>(pXMLDocumentNode);
         pXMLDocumentElement->GetNamespaceURI(wsNamespaceURI);
@@ skipping 23 matching lines @@
       pChecksum->StartChecksum();
       pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[0],
                                 m_pXMLParser->m_nSize[0]);
       pChecksum->UpdateChecksum(m_pFileRead, m_pXMLParser->m_nStart[1],
                                 m_pXMLParser->m_nSize[1]);
       pChecksum->FinishChecksum();
       CFX_ByteString bsCheck = pChecksum->GetChecksum();
       if (bsCheck != wsChecksum.UTF8Encode())
         return nullptr;
 
-      pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form);
+      pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Form, XFA_Element::Form);
       if (!pNode)
         return nullptr;
 
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_Form)->pName);
       pNode->SetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum.AsStringC());
       CXFA_Node* pTemplateRoot =
-          m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Template);
+          m_pRootNode->GetFirstChildByClass(XFA_Element::Template);
       CXFA_Node* pTemplateChosen =
           pTemplateRoot
-              ? pTemplateRoot->GetFirstChildByClass(XFA_ELEMENT_Subform)
+              ? pTemplateRoot->GetFirstChildByClass(XFA_Element::Subform)
               : NULL;
       FX_BOOL bUseAttribute = TRUE;
       if (pTemplateChosen &&
           pTemplateChosen->GetEnum(XFA_ATTRIBUTE_RestoreState) !=
               XFA_ATTRIBUTEENUM_Auto) {
         bUseAttribute = FALSE;
       }
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, bUseAttribute)) {
         return NULL;
       }
@@ skipping 30 matching lines @@
     return pDatasetsNode;
   }
   return NULL;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Data(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CFDE_XMLNode* pDatasetsXMLNode = XFA_GetDataSetsFromXDP(pXMLDocumentNode);
   if (pDatasetsXMLNode) {
     CXFA_Node* pNode =
-        m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataModel);
+        m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataModel);
     if (!pNode) {
       return NULL;
     }
     pNode->SetCData(XFA_ATTRIBUTE_Name,
                     XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName);
     if (!DataLoader(pNode, pDatasetsXMLNode, FALSE)) {
       return NULL;
     }
     pNode->SetXMLMappingNode(pDatasetsXMLNode);
     return pNode;
@@ skipping 16 matching lines @@
     ASSERT(pXMLDocumentNode->GetType() == FDE_XMLNODE_Element);
     if (pXMLDocumentNode->GetType() == FDE_XMLNODE_Element) {
       static_cast<CFDE_XMLElement*>(pXMLDocumentNode)
           ->RemoveAttribute(L"xmlns:xfa");
     }
     pDataElement->InsertChildNode(pXMLDocumentNode);
     pDataXMLNode = pDataElement;
   }
   if (pDataXMLNode) {
     CXFA_Node* pNode =
-        m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataGroup);
+        m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, XFA_Element::DataGroup);
     if (!pNode) {
       if (pDataXMLNode != pXMLDocumentNode) {
         pDataXMLNode->Release();
       }
       return NULL;
     }
     CFX_WideString wsLocalName;
     static_cast<CFDE_XMLElement*>(pDataXMLNode)->GetLocalTagName(wsLocalName);
     pNode->SetCData(XFA_ATTRIBUTE_Name, wsLocalName);
     if (!DataLoader(pNode, pDataXMLNode, TRUE)) {
@@ skipping 10 matching lines @@
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = NULL;
   if (ePacketID == XFA_XDPPACKET_LocaleSet) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_LocaleSet,
-                                     XFA_ELEMENT_LocaleSet);
+                                     XFA_Element::LocaleSet);
       if (!pNode) {
         return NULL;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName);
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
         return NULL;
       }
     }
   } else if (ePacketID == XFA_XDPPACKET_ConnectionSet) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode,
             XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_ConnectionSet,
-                                     XFA_ELEMENT_ConnectionSet);
+                                     XFA_Element::ConnectionSet);
       if (!pNode) {
         return NULL;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName);
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
         return NULL;
       }
     }
   } else if (ePacketID == XFA_XDPPACKET_SourceSet) {
     if (XFA_FDEExtension_MatchNodeName(
             pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_SourceSet,
-                                     XFA_ELEMENT_SourceSet);
+                                     XFA_Element::SourceSet);
       if (!pNode) {
         return NULL;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName);
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
         return NULL;
       }
     }
   }
   if (pNode) {
     pNode->SetXMLMappingNode(pXMLDocumentNode);
   }
   return pNode;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Xdc(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   if (XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_Xdc)->eFlags)) {
     CXFA_Node* pNode =
-        m_pFactory->CreateNode(XFA_XDPPACKET_Xdc, XFA_ELEMENT_Xdc);
+        m_pFactory->CreateNode(XFA_XDPPACKET_Xdc, XFA_Element::Xdc);
     if (!pNode) {
       return NULL;
     }
     pNode->SetCData(XFA_ATTRIBUTE_Name,
                     XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName);
     pNode->SetXMLMappingNode(pXMLDocumentNode);
     return pNode;
   }
   return NULL;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_User(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode =
-      m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_ELEMENT_Packet);
+      m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_Element::Packet);
   if (!pNode) {
     return NULL;
   }
   CFX_WideString wsName;
   static_cast<CFDE_XMLElement*>(pXMLDocumentNode)->GetLocalTagName(wsName);
   pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
   if (!UserPacketLoader(pNode, pXMLDocumentNode)) {
     return NULL;
   }
   pNode->SetXMLMappingNode(pXMLDocumentNode);
@@ skipping 67 matching lines @@
           if (!lpAttrInfo) {
             continue;
           }
           if (!bUseAttribute && lpAttrInfo->eName != XFA_ATTRIBUTE_Name &&
               lpAttrInfo->eName != XFA_ATTRIBUTE_Save) {
             continue;
           }
           pXFAChild->SetAttribute(lpAttrInfo->eName, wsAttrValue.AsStringC());
         }
         pXFANode->InsertChild(pXFAChild);
-        if (pElemInfo->eName == XFA_ELEMENT_Validate ||
-            pElemInfo->eName == XFA_ELEMENT_Locale) {
+        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:
@@ skipping 76 matching lines @@
       default:
         ASSERT(FALSE);
         break;
     }
   }
 }
 
 void CXFA_SimpleParser::ParseContentNode(CXFA_Node* pXFANode,
                                          CFDE_XMLNode* pXMLNode,
                                          XFA_XDPPACKET ePacketID) {
-  XFA_ELEMENT element = XFA_ELEMENT_Sharptext;
-  if (pXFANode->GetClassID() == XFA_ELEMENT_ExData) {
+  XFA_Element element = XFA_Element::Sharptext;
+  if (pXFANode->GetClassID() == XFA_Element::ExData) {
     CFX_WideStringC wsContentType =
         pXFANode->GetCData(XFA_ATTRIBUTE_ContentType);
     if (wsContentType == FX_WSTRC(L"text/html"))
-      element = XFA_ELEMENT_SharpxHTML;
+      element = XFA_Element::SharpxHTML;
     else if (wsContentType == FX_WSTRC(L"text/xml"))
-      element = XFA_ELEMENT_Sharpxml;
+      element = XFA_Element::Sharpxml;
   }
-  if (element == XFA_ELEMENT_SharpxHTML)
+  if (element == XFA_Element::SharpxHTML)
     pXFANode->SetXMLMappingNode(pXMLNode);
 
   CFX_WideString wsValue;
   for (CFDE_XMLNode* pXMLChild =
            pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
        pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     FDE_XMLNODETYPE eNodeType = pXMLChild->GetType();
     if (eNodeType == FDE_XMLNODE_Instruction)
       continue;
 
-    if (element == XFA_ELEMENT_SharpxHTML) {
+    if (element == XFA_Element::SharpxHTML) {
       if (eNodeType != FDE_XMLNODE_Element)
         break;
 
       if (XFA_RecognizeRichText(static_cast<CFDE_XMLElement*>(pXMLChild)))
         XFA_GetPlainTextFromRichText(static_cast<CFDE_XMLElement*>(pXMLChild),
                                      wsValue);
-    } else if (element == XFA_ELEMENT_Sharpxml) {
+    } else if (element == XFA_Element::Sharpxml) {
       if (eNodeType != FDE_XMLNODE_Element)
         break;
       XFA_ConvertXMLToPlainText(static_cast<CFDE_XMLElement*>(pXMLChild),
                                 wsValue);
     } else {
       if (eNodeType == FDE_XMLNODE_Element)
         break;
       if (eNodeType == FDE_XMLNODE_Text)
         static_cast<CFDE_XMLText*>(pXMLChild)->GetText(wsValue);
       else if (eNodeType == FDE_XMLNODE_CharData)
@@ skipping 33 matching lines @@
               wsNamespaceURI ==
                   FX_WSTRC(L"http://www.xfa.org/schema/xfa-package/") ||
               wsNamespaceURI ==
                   FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance")) {
             continue;
           }
           if (0) {
             continue;
           }
         }
-        XFA_ELEMENT eNodeType = XFA_ELEMENT_DataModel;
-        if (eNodeType == XFA_ELEMENT_DataModel) {
+        XFA_Element eNodeType = XFA_Element::DataModel;
+        if (eNodeType == XFA_Element::DataModel) {
           CFX_WideString wsDataNodeAttr;
           if (XFA_FDEExtension_FindAttributeWithNS(
                   pXMLElement, FX_WSTRC(L"dataNode"),
                   FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"),
                   wsDataNodeAttr)) {
             if (wsDataNodeAttr == FX_WSTRC(L"dataGroup")) {
-              eNodeType = XFA_ELEMENT_DataGroup;
+              eNodeType = XFA_Element::DataGroup;
             } else if (wsDataNodeAttr == FX_WSTRC(L"dataValue")) {
-              eNodeType = XFA_ELEMENT_DataValue;
+              eNodeType = XFA_Element::DataValue;
             }
           }
         }
         CFX_WideString wsContentType;
-        if (eNodeType == XFA_ELEMENT_DataModel) {
+        if (eNodeType == XFA_Element::DataModel) {
           if (XFA_FDEExtension_FindAttributeWithNS(
                   pXMLElement, FX_WSTRC(L"contentType"),
                   FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/"),
                   wsContentType)) {
             if (!wsContentType.IsEmpty()) {
-              eNodeType = XFA_ELEMENT_DataValue;
+              eNodeType = XFA_Element::DataValue;
             }
           }
         }
-        if (eNodeType == XFA_ELEMENT_DataModel) {
+        if (eNodeType == XFA_Element::DataModel) {
           for (CFDE_XMLNode* pXMLDataChild =
                    pXMLElement->GetNodeItem(CFDE_XMLNode::FirstChild);
                pXMLDataChild; pXMLDataChild = pXMLDataChild->GetNodeItem(
                                   CFDE_XMLNode::NextSibling)) {
             if (pXMLDataChild->GetType() == FDE_XMLNODE_Element) {
               if (!XFA_RecognizeRichText(
                       static_cast<CFDE_XMLElement*>(pXMLDataChild))) {
-                eNodeType = XFA_ELEMENT_DataGroup;
+                eNodeType = XFA_Element::DataGroup;
                 break;
               }
             }
           }
         }
-        if (eNodeType == XFA_ELEMENT_DataModel) {
-          eNodeType = XFA_ELEMENT_DataValue;
+        if (eNodeType == XFA_Element::DataModel) {
+          eNodeType = XFA_Element::DataValue;
         }
         CXFA_Node* pXFAChild =
             m_pFactory->CreateNode(XFA_XDPPACKET_Datasets, eNodeType);
         if (pXFAChild == NULL) {
           return;
         }
         CFX_WideString wsNodeName;
         pXMLElement->GetLocalTagName(wsNodeName);
         pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeName);
         FX_BOOL bNeedValue = TRUE;
@@ skipping 22 matching lines @@
                 wsAttrNamespaceURI ==
                     FX_WSTRC(L"http://www.w3.org/2001/XMLSchema-instance") ||
                 wsAttrNamespaceURI ==
                     FX_WSTRC(L"http://www.xfa.org/schema/xfa-data/1.0/")) {
               continue;
             }
             if (0) {
               continue;
             }
             CXFA_Node* pXFAMetaData = m_pFactory->CreateNode(
-                XFA_XDPPACKET_Datasets, XFA_ELEMENT_DataValue);
+                XFA_XDPPACKET_Datasets, XFA_Element::DataValue);
             if (pXFAMetaData == NULL) {
               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);
           }
           if (!bNeedValue) {
             CFX_WideString wsNilName(L"xsi:nil");
             pXMLElement->RemoveAttribute(wsNilName.c_str());
           }
         }
         pXFANode->InsertChild(pXFAChild);
-        if (eNodeType == XFA_ELEMENT_DataGroup) {
+        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);
       }
         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);
+                                                      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);
       }
         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);
+                                                      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);
       }
         continue;
       case FDE_XMLNODE_Instruction:
@@ skipping 39 matching lines @@
       if (!pXMLCurValueNode)
         pXMLCurValueNode = pXMLChild;
 
       wsCurValueTextBuf << wsText;
     } else {
       bMarkAsCompound = TRUE;
       if (pXMLCurValueNode) {
         CFX_WideString wsCurValue = wsCurValueTextBuf.MakeString();
         if (!wsCurValue.IsEmpty()) {
           CXFA_Node* pXFAChild =
-              m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
+              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);
           wsValueTextBuf << wsCurValue;
           wsCurValueTextBuf.Clear();
         }
         pXMLCurValueNode = nullptr;
       }
       CXFA_Node* pXFAChild =
-          m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
+          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);
       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);
+            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);
       }
       wsValueTextBuf << wsCurValue;
@@ skipping 287 matching lines @@
     }
     if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return (m_syntaxParserResult == FDE_XmlSyntaxResult::Error ||
           m_NodeStack.GetSize() != 1)
              ? -1
              : m_pParser->GetStatus();
 }