Remove IFDE_XML* classes.

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 "core/fxcrt/include/fx_ext.h"
+#include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/crt/fgas_system.h"
 #include "xfa/fxfa/fm2js/xfa_fm2jsapi.h"
 #include "xfa/fxfa/parser/xfa_basic_imp.h"
 #include "xfa/fxfa/parser/xfa_docdata.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_document_layout_imp.h"
 #include "xfa/fxfa/parser/xfa_localemgr.h"
 #include "xfa/fxfa/parser/xfa_parser.h"
@@ skipping 97 matching lines @@
 }
 CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive) {
   IXFA_ObjFactory* pFactory = m_pDocument->GetParser()->GetFactory();
   CXFA_Node* pClone = pFactory->CreateNode(m_ePacket, m_eNodeClass);
   if (!pClone) {
     return NULL;
   }
   MergeAllData(pClone);
   pClone->UpdateNameHash();
   if (IsNeedSavingXMLNode()) {
-    IFDE_XMLNode* pCloneXML = NULL;
+    CFDE_XMLNode* pCloneXML = NULL;
     if (IsAttributeInXML()) {
       CFX_WideString wsName;
       GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
-      IFDE_XMLElement* pCloneXMLElement = IFDE_XMLElement::Create(wsName);
+      CFDE_XMLElement* pCloneXMLElement = new CFDE_XMLElement(wsName);
       CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pCloneXMLElement->SetTextData(wsValue);
       }
       pCloneXML = pCloneXMLElement;
       pCloneXMLElement = NULL;
       pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       pCloneXML = m_pXMLNode->Clone(FALSE);
     }
@@ skipping 813 matching lines @@
   if (iLength >= 2) {
     bIgnoreRoot = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
   }
   if (iLength >= 3) {
     bOverwrite = pArguments->GetInt32(2) == 0 ? FALSE : TRUE;
   }
   IXFA_Parser* pParser = IXFA_Parser::Create(m_pDocument);
   if (!pParser) {
     return;
   }
-  IFDE_XMLNode* pXMLNode = NULL;
+  CFDE_XMLNode* pXMLNode = NULL;
   int32_t iParserStatus = pParser->ParseXMLData(wsExpression, pXMLNode, NULL);
   if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode) {
     pParser->Release();
     pParser = NULL;
     return;
   }
-  if (bIgnoreRoot && (pXMLNode->GetType() != FDE_XMLNODE_Element ||
-                      XFA_RecognizeRichText((IFDE_XMLElement*)pXMLNode))) {
+  if (bIgnoreRoot &&
+      (pXMLNode->GetType() != FDE_XMLNODE_Element ||
+       XFA_RecognizeRichText(static_cast<CFDE_XMLElement*>(pXMLNode)))) {
     bIgnoreRoot = FALSE;
   }
   CXFA_Node* pFakeRoot = Clone(FALSE);
   CFX_WideStringC wsContentType = GetCData(XFA_ATTRIBUTE_ContentType);
   if (!wsContentType.IsEmpty()) {
     pFakeRoot->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
   }
-  IFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode();
+  CFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode();
   if (!pFakeXMLRoot) {
-    IFDE_XMLNode* pThisXMLRoot = GetXMLMappingNode();
+    CFDE_XMLNode* pThisXMLRoot = GetXMLMappingNode();
     pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : NULL;
   }
   if (!pFakeXMLRoot) {
     CFX_WideStringC wsClassName;
     GetClassName(wsClassName);
-    pFakeXMLRoot = IFDE_XMLElement::Create(wsClassName);
+    pFakeXMLRoot = new CFDE_XMLElement(wsClassName);
   }
   if (bIgnoreRoot) {
-    IFDE_XMLNode* pXMLChild = pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
+    CFDE_XMLNode* pXMLChild = pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
     while (pXMLChild) {
-      IFDE_XMLNode* pXMLSibling =
-          pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling);
+      CFDE_XMLNode* pXMLSibling =
+          pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling);
       pXMLNode->RemoveChildNode(pXMLChild);
       pFakeXMLRoot->InsertChildNode(pXMLChild);
       pXMLChild = pXMLSibling;
     }
   } else {
-    IFDE_XMLNode* pXMLParent = pXMLNode->GetNodeItem(IFDE_XMLNode::Parent);
+    CFDE_XMLNode* pXMLParent = pXMLNode->GetNodeItem(CFDE_XMLNode::Parent);
     if (pXMLParent) {
       pXMLParent->RemoveChildNode(pXMLNode);
     }
     pFakeXMLRoot->InsertChildNode(pXMLNode);
   }
   pParser->ConstructXFANode(pFakeRoot, pFakeXMLRoot);
   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);
         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) {
-        IFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
+        CFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
         SetXMLMappingNode(pFakeXMLRoot);
         SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
         if (pTempXMLNode &&
-            pTempXMLNode->GetNodeItem(IFDE_XMLNode::Parent) == NULL) {
+            pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL) {
           pFakeXMLRoot = pTempXMLNode;
         } else {
           pFakeXMLRoot = NULL;
         }
       }
       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);
@@ skipping 55 matching lines @@
         CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
     pStream->Release();
     pStream = NULL;
     if (pMemoryStream) {
       pMemoryStream->Release();
       pMemoryStream = NULL;
     }
     return;
   }
   if (GetPacketID() == XFA_XDPPACKET_Datasets) {
-    IFDE_XMLNode* pElement = GetXMLMappingNode();
+    CFDE_XMLNode* pElement = GetXMLMappingNode();
     if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
       FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
       return;
     }
     XFA_DataExporter_DealWithDataGroupNode(this);
     IFX_MemoryStream* pMemoryStream = FX_CreateMemoryStream(TRUE);
     IFX_Stream* pStream = IFX_Stream::CreateStream(
         (IFX_FileWrite*)pMemoryStream,
         FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
     if (pStream) {
@@ skipping 2373 matching lines @@
     GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE);
     FXJSE_Value_SetUTF8String(
         hValue, FX_UTF8Encode(wsChecksum, wsChecksum.GetLength()));
   }
 }
 void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString bsAttributeName = pArguments->GetUTF8String(0);
     CFX_WideString wsAttributeValue;
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+    CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      ((IFDE_XMLElement*)pXMLNode)
+      static_cast<CFDE_XMLElement*>(pXMLNode)
           ->GetString(CFX_WideString::FromUTF8(bsAttributeName,
                                                bsAttributeName.GetLength()),
                       wsAttributeValue);
     }
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
         FX_UTF8Encode(wsAttributeValue, wsAttributeValue.GetLength()));
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"getAttribute");
   }
 }
 void CXFA_Node::Script_Packet_SetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 2) {
     CFX_ByteString bsValue = pArguments->GetUTF8String(0);
     CFX_ByteString bsName = pArguments->GetUTF8String(1);
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+    CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      ((IFDE_XMLElement*)pXMLNode)
+      static_cast<CFDE_XMLElement*>(pXMLNode)
           ->SetString(CFX_WideString::FromUTF8(bsName, bsName.GetLength()),
                       CFX_WideString::FromUTF8(bsValue, bsValue.GetLength()));
     }
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"setAttribute");
   }
 }
 void CXFA_Node::Script_Packet_RemoveAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString bsName = pArguments->GetUTF8String(0);
     CFX_WideString wsName =
         CFX_WideString::FromUTF8(bsName, bsName.GetLength());
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+    CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
+      CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       if (pXMLElement->HasAttribute(wsName)) {
         pXMLElement->RemoveAttribute(wsName);
       }
     }
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"removeAttribute");
   }
 }
 void CXFA_Node::Script_Packet_Content(FXJSE_HVALUE hValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString bsNewContent;
     FXJSE_Value_ToUTF8String(hValue, bsNewContent);
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+    CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
+      CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->SetTextData(
           CFX_WideString::FromUTF8(bsNewContent, bsNewContent.GetLength()));
     }
   } else {
     CFX_WideString wsTextData;
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+    CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
-      IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)pXMLNode;
+      CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->GetTextData(wsTextData);
     }
     FXJSE_Value_SetUTF8String(
         hValue, FX_UTF8Encode(wsTextData, wsTextData.GetLength()));
   }
 }
 void CXFA_Node::Script_Source_Next(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
@@ skipping 372 matching lines @@
     if (eAttr == XFA_ATTRIBUTE_Name &&
         (m_eNodeClass == XFA_ELEMENT_DataValue ||
          m_eNodeClass == XFA_ELEMENT_DataGroup)) {
       return TRUE;
     }
     if (eAttr == XFA_ATTRIBUTE_Value) {
       FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
       switch (eXMLType) {
         case FDE_XMLNODE_Element:
           if (IsAttributeInXML()) {
-            ((IFDE_XMLElement*)m_pXMLNode)
+            static_cast<CFDE_XMLElement*>(m_pXMLNode)
                 ->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsValue);
           } else {
             FX_BOOL bDeleteChildren = TRUE;
             if (GetPacketID() == XFA_XDPPACKET_Datasets) {
               for (CXFA_Node* pChildDataNode =
                        GetNodeItem(XFA_NODEITEM_FirstChild);
                    pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(
                                        XFA_NODEITEM_NextSibling)) {
                 CXFA_NodeArray formNodes;
                 if (pChildDataNode->GetBindItems(formNodes) > 0) {
                   bDeleteChildren = FALSE;
                   break;
                 }
               }
             }
             if (bDeleteChildren) {
-              ((IFDE_XMLElement*)m_pXMLNode)->DeleteChildren();
+              static_cast<CFDE_XMLElement*>(m_pXMLNode)->DeleteChildren();
             }
-            ((IFDE_XMLElement*)m_pXMLNode)->SetTextData(wsValue);
+            static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetTextData(wsValue);
           }
           break;
         case FDE_XMLNODE_Text:
-          ((IFDE_XMLText*)m_pXMLNode)->SetText(wsValue);
+          static_cast<CFDE_XMLText*>(m_pXMLNode)->SetText(wsValue);
           break;
         default:
           FXSYS_assert(0);
       }
       return TRUE;
     }
     const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
     if (pInfo) {
       FXSYS_assert(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
       CFX_WideString wsAttrName = pInfo->pName;
       if (pInfo->eName == XFA_ATTRIBUTE_ContentType) {
         wsAttrName = FX_WSTRC(L"xfa:") + wsAttrName;
       }
-      ((IFDE_XMLElement*)m_pXMLNode)->SetString(wsAttrName, wsValue);
+      static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetString(wsAttrName, wsValue);
     }
   }
   return TRUE;
 }
 FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue,
                                      const CFX_WideString& wsXMLValue,
                                      FX_BOOL bNotify,
                                      FX_BOOL bScriptModify) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), XFA_ATTRIBUTE_Value);
   OnChanging(XFA_ATTRIBUTE_Value, (void*)(const FX_WCHAR*)wsValue, bNotify);
   CFX_WideString* pClone = new CFX_WideString(wsValue);
   SetUserData(pKey, pClone, &deleteWideStringCallBack);
   OnChanged(XFA_ATTRIBUTE_Value, (void*)(const FX_WCHAR*)wsValue, bNotify,
             bScriptModify);
   if (IsNeedSavingXMLNode()) {
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
-          ((IFDE_XMLElement*)m_pXMLNode)
+          static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsXMLValue);
         } else {
           FX_BOOL bDeleteChildren = TRUE;
           if (GetPacketID() == XFA_XDPPACKET_Datasets) {
             for (CXFA_Node* pChildDataNode =
                      GetNodeItem(XFA_NODEITEM_FirstChild);
                  pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(
                                      XFA_NODEITEM_NextSibling)) {
               CXFA_NodeArray formNodes;
               if (pChildDataNode->GetBindItems(formNodes) > 0) {
                 bDeleteChildren = FALSE;
                 break;
               }
             }
           }
           if (bDeleteChildren) {
-            ((IFDE_XMLElement*)m_pXMLNode)->DeleteChildren();
+            static_cast<CFDE_XMLElement*>(m_pXMLNode)->DeleteChildren();
           }
-          ((IFDE_XMLElement*)m_pXMLNode)->SetTextData(wsXMLValue);
+          static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetTextData(wsXMLValue);
         }
         break;
       case FDE_XMLNODE_Text:
-        ((IFDE_XMLText*)m_pXMLNode)->SetText(wsXMLValue);
+        static_cast<CFDE_XMLText*>(m_pXMLNode)->SetText(wsXMLValue);
         break;
       default:
         FXSYS_assert(0);
     }
   }
   return TRUE;
 }
 FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
                             CFX_WideString& wsValue,
                             FX_BOOL bUseDefault,
@@ skipping 68 matching lines @@
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   OnChanging(eAttr, pValue, bNotify);
   SetMapModuleValue(pKey, pValue);
   OnChanged(eAttr, pValue, bNotify);
   if (IsNeedSavingXMLNode()) {
     FXSYS_assert(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
     const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
     if (pInfo) {
       switch (eType) {
         case XFA_ATTRIBUTETYPE_Enum:
-          ((IFDE_XMLElement*)m_pXMLNode)
+          static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(
                   pInfo->pName,
                   XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue)
                       ->pName);
           break;
         case XFA_ATTRIBUTETYPE_Boolean:
-          ((IFDE_XMLElement*)m_pXMLNode)
+          static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(pInfo->pName,
                           pValue ? FX_WSTRC(L"1") : FX_WSTRC(L"0"));
           break;
         case XFA_ATTRIBUTETYPE_Integer:
-          ((IFDE_XMLElement*)m_pXMLNode)
+          static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetInteger(pInfo->pName, (int32_t)(uintptr_t)pValue);
           break;
         default:
           FXSYS_assert(0);
       }
     }
   }
   return TRUE;
 }
 FX_BOOL CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr,
@@ skipping 302 matching lines @@
     case XFA_XDPPACKET_Xdc:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
     default:
       return this;
   }
 }
 FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
   wsNamespace.Empty();
   if (GetObjectType() == XFA_OBJECTTYPE_ModelNode ||
       GetClassID() == XFA_ELEMENT_Packet) {
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+    CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return FALSE;
     }
-    ((IFDE_XMLElement*)pXMLNode)->GetNamespaceURI(wsNamespace);
+    static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
-    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
+    CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode) {
       return FALSE;
     }
     if (pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return TRUE;
     }
     if (GetClassID() == XFA_ELEMENT_DataValue &&
         GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) {
       return XFA_FDEExtension_ResolveNamespaceQualifier(
-          (IFDE_XMLElement*)pXMLNode, GetCData(XFA_ATTRIBUTE_QualifiedName),
-          wsNamespace);
+          static_cast<CFDE_XMLElement*>(pXMLNode),
+          GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace);
     }
-    ((IFDE_XMLElement*)pXMLNode)->GetNamespaceURI(wsNamespace);
+    static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else {
     CXFA_Node* pModelNode = GetModelNode();
     return pModelNode->TryNamespace(wsNamespace);
   }
 }
 CXFA_Node* CXFA_Node::GetProperty(int32_t index,
                                   XFA_ELEMENT eProperty,
                                   FX_BOOL bCreateProperty) {
   XFA_ELEMENT eElement = GetClassID();
@@ skipping 112 matching lines @@
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
   ASSERT(m_pLastChild->m_pNext == NULL);
   pNode->SetFlag(XFA_NODEFLAG_HasRemoved, FALSE);
   IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (pNotify) {
     pNotify->OnNodeEvent(this, XFA_NODEEVENT_ChildAdded, pNode);
   }
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
-    FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(IFDE_XMLNode::Parent) == NULL);
+    FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL);
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index);
     pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, FALSE, FALSE);
   }
   return index;
 }
 FX_BOOL CXFA_Node::InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode) {
   if (!pNode || pNode->m_pParent ||
       (pBeforeNode && pBeforeNode->m_pParent != this)) {
     FXSYS_assert(false);
     return FALSE;
@@ skipping 25 matching lines @@
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
   ASSERT(m_pLastChild->m_pNext == NULL);
   pNode->SetFlag(XFA_NODEFLAG_HasRemoved, FALSE);
   IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (pNotify) {
     pNotify->OnNodeEvent(this, XFA_NODEEVENT_ChildAdded, pNode);
   }
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
-    FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(IFDE_XMLNode::Parent) == NULL);
+    FXSYS_assert(pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent) == NULL);
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex);
     pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, FALSE, FALSE);
   }
   return TRUE;
 }
 CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling() {
   if (!m_pParent) {
     return NULL;
   }
   for (CXFA_Node* pSibling = m_pParent->m_pChild; pSibling;
@@ skipping 27 matching lines @@
   }
   ASSERT(m_pLastChild == NULL || m_pLastChild->m_pNext == NULL);
   OnRemoved(this, pNode, bNotify);
   pNode->SetFlag(XFA_NODEFLAG_HasRemoved);
   m_pDocument->AddPurgeNode(pNode);
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     if (pNode->IsAttributeInXML()) {
       FXSYS_assert(pNode->m_pXMLNode == m_pXMLNode &&
                    m_pXMLNode->GetType() == FDE_XMLNODE_Element);
       if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) {
-        IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)(pNode->m_pXMLNode);
+        CFDE_XMLElement* pXMLElement =
+            static_cast<CFDE_XMLElement*>(pNode->m_pXMLNode);
         CFX_WideStringC wsAttributeName =
             pNode->GetCData(XFA_ATTRIBUTE_QualifiedName);
         pXMLElement->RemoveAttribute(wsAttributeName.GetPtr());
       }
       CFX_WideString wsName;
       pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
-      IFDE_XMLElement* pNewXMLElement = IFDE_XMLElement::Create(wsName);
+      CFDE_XMLElement* pNewXMLElement = new CFDE_XMLElement(wsName);
       CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pNewXMLElement->SetTextData(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, TRUE, FALSE);
@@ skipping 232 matching lines @@
         wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
                                                        wsName.GetLength());
   } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
     CFX_WideStringC wsName =
         XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
     m_dwNameHash =
         wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
                                                        wsName.GetLength());
   }
 }
-IFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
+CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideStringC wsTag = GetCData(XFA_ATTRIBUTE_Name);
-    m_pXMLNode = IFDE_XMLElement::Create(wsTag);
+    m_pXMLNode = new CFDE_XMLElement(wsTag);
     SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, 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() {
@@ skipping 414 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);
 }