Remove IFDE_XML* classes.

xfa/fde/xml/fde_xml_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/fde/xml/fde_xml_imp.h"
 
 #include <algorithm>
 
@@ skipping 125 matching lines @@
     ch = *pStart++;
     if (ch == L'/') {
       break;
     } else {
       csPath += ch;
     }
   }
   iLength -= pStart - pPath;
   CFDE_XMLNode* pFind = NULL;
   if (csPath.GetLength() < 1) {
-    pFind = GetNodeItem(IFDE_XMLNode::Root);
+    pFind = GetNodeItem(CFDE_XMLNode::Root);
   } else if (csPath.Compare(L"..") == 0) {
     pFind = m_pParent;
   } else if (csPath.Compare(L".") == 0) {
     pFind = (CFDE_XMLNode*)this;
   } else {
     CFX_WideString wsTag;
     CFDE_XMLNode* pNode = m_pChild;
     while (pNode != NULL) {
       if (pNode->GetType() == FDE_XMLNODE_Element) {
         if (bQualifiedName) {
@@ skipping 55 matching lines @@
   } else {
     pNode->m_pPrior->m_pNext = pNode->m_pNext;
   }
   if (pNode->m_pNext != NULL) {
     pNode->m_pNext->m_pPrior = pNode->m_pPrior;
   }
   pNode->m_pParent = NULL;
   pNode->m_pNext = NULL;
   pNode->m_pPrior = NULL;
 }
-CFDE_XMLNode* CFDE_XMLNode::GetNodeItem(IFDE_XMLNode::NodeItem eItem) const {
+CFDE_XMLNode* CFDE_XMLNode::GetNodeItem(CFDE_XMLNode::NodeItem eItem) const {
   switch (eItem) {
-    case IFDE_XMLNode::Root: {
+    case CFDE_XMLNode::Root: {
       CFDE_XMLNode* pParent = (CFDE_XMLNode*)this;
       while (pParent->m_pParent != NULL) {
         pParent = pParent->m_pParent;
       }
       return pParent;
     }
-    case IFDE_XMLNode::Parent:
+    case CFDE_XMLNode::Parent:
       return m_pParent;
-    case IFDE_XMLNode::FirstSibling: {
+    case CFDE_XMLNode::FirstSibling: {
       CFDE_XMLNode* pItem = (CFDE_XMLNode*)this;
       while (pItem->m_pPrior != NULL) {
         pItem = pItem->m_pPrior;
       }
       return pItem == (CFDE_XMLNode*)this ? NULL : pItem;
     }
-    case IFDE_XMLNode::PriorSibling:
+    case CFDE_XMLNode::PriorSibling:
       return m_pPrior;
-    case IFDE_XMLNode::NextSibling:
+    case CFDE_XMLNode::NextSibling:
       return m_pNext;
-    case IFDE_XMLNode::LastSibling: {
+    case CFDE_XMLNode::LastSibling: {
       CFDE_XMLNode* pItem = (CFDE_XMLNode*)this;
       while (pItem->m_pNext != NULL) {
         pItem = pItem->m_pNext;
       }
       return pItem == (CFDE_XMLNode*)this ? NULL : pItem;
     }
-    case IFDE_XMLNode::FirstNeighbor: {
+    case CFDE_XMLNode::FirstNeighbor: {
       CFDE_XMLNode* pParent = (CFDE_XMLNode*)this;
       while (pParent->m_pParent != NULL) {
         pParent = pParent->m_pParent;
       }
       return pParent == (CFDE_XMLNode*)this ? NULL : pParent;
     }
-    case IFDE_XMLNode::PriorNeighbor: {
+    case CFDE_XMLNode::PriorNeighbor: {
       if (m_pPrior == NULL) {
         return m_pParent;
       }
       CFDE_XMLNode* pItem = m_pPrior;
       while (CFDE_XMLNode* pTemp = pItem->m_pChild) {
         pItem = pTemp;
         while ((pTemp = pItem->m_pNext) != NULL) {
           pItem = pTemp;
         }
       }
       return pItem;
     }
-    case IFDE_XMLNode::NextNeighbor: {
+    case CFDE_XMLNode::NextNeighbor: {
       if (m_pChild != NULL) {
         return m_pChild;
       }
       if (m_pNext != NULL) {
         return m_pNext;
       }
       CFDE_XMLNode* pItem = m_pParent;
       while (pItem != NULL) {
         if (pItem->m_pNext != NULL) {
           return pItem->m_pNext;
         }
         pItem = pItem->m_pParent;
       }
       return NULL;
     }
-    case IFDE_XMLNode::LastNeighbor: {
+    case CFDE_XMLNode::LastNeighbor: {
       CFDE_XMLNode* pItem = (CFDE_XMLNode*)this;
       while (pItem->m_pParent != NULL) {
         pItem = pItem->m_pParent;
       }
       while (TRUE) {
         while (pItem->m_pNext != NULL) {
           pItem = pItem->m_pNext;
         }
         if (pItem->m_pChild == NULL) {
           break;
         }
         pItem = pItem->m_pChild;
       }
       return pItem == (CFDE_XMLNode*)this ? NULL : pItem;
     }
-    case IFDE_XMLNode::FirstChild:
+    case CFDE_XMLNode::FirstChild:
       return m_pChild;
-    case IFDE_XMLNode::LastChild: {
+    case CFDE_XMLNode::LastChild: {
       if (m_pChild == NULL) {
         return NULL;
       }
       CFDE_XMLNode* pChild = m_pChild;
       while (pChild->m_pNext != NULL) {
         pChild = pChild->m_pNext;
       }
       return pChild;
     }
     default:
       break;
   }
   return NULL;
 }
 int32_t CFDE_XMLNode::GetNodeLevel() const {
   int32_t iLevel = 0;
   CFDE_XMLNode* pItem = (CFDE_XMLNode*)this;
   while ((pItem = pItem->m_pParent) != NULL) {
     iLevel++;
   }
   return iLevel;
 }
-FX_BOOL CFDE_XMLNode::InsertNodeItem(IFDE_XMLNode::NodeItem eItem,
+FX_BOOL CFDE_XMLNode::InsertNodeItem(CFDE_XMLNode::NodeItem eItem,
                                      CFDE_XMLNode* pNode) {
   FXSYS_assert(pNode != NULL);
   switch (eItem) {
-    case IFDE_XMLNode::NextSibling: {
+    case CFDE_XMLNode::NextSibling: {
       pNode->m_pParent = m_pParent;
       pNode->m_pNext = m_pNext;
       pNode->m_pPrior = this;
       if (m_pNext) {
         m_pNext->m_pPrior = pNode;
       }
       m_pNext = pNode;
       return TRUE;
     }
-    case IFDE_XMLNode::PriorSibling: {
+    case CFDE_XMLNode::PriorSibling: {
       pNode->m_pParent = m_pParent;
       pNode->m_pNext = this;
       pNode->m_pPrior = m_pPrior;
       if (m_pPrior) {
         m_pPrior->m_pNext = pNode;
       } else if (m_pParent) {
         m_pParent->m_pChild = pNode;
       }
       m_pPrior = pNode;
       return TRUE;
     }
     default:
       return FALSE;
   }
   return FALSE;
 }
-CFDE_XMLNode* CFDE_XMLNode::RemoveNodeItem(IFDE_XMLNode::NodeItem eItem) {
+CFDE_XMLNode* CFDE_XMLNode::RemoveNodeItem(CFDE_XMLNode::NodeItem eItem) {
   CFDE_XMLNode* pNode = NULL;
   switch (eItem) {
-    case IFDE_XMLNode::NextSibling:
+    case CFDE_XMLNode::NextSibling:
       if (m_pNext) {
         pNode = m_pNext;
         m_pNext = pNode->m_pNext;
         if (m_pNext) {
           m_pNext->m_pPrior = this;
         }
         pNode->m_pParent = NULL;
         pNode->m_pNext = NULL;
         pNode->m_pPrior = NULL;
       }
@@ skipping 120 matching lines @@
 void CFDE_XMLNode::CloneChildren(CFDE_XMLNode* pClone) {
   if (!m_pChild) {
     return;
   }
   CFDE_XMLNode* pNext = m_pChild;
   CFDE_XMLNode* pCloneNext = pNext->Clone(TRUE);
   pClone->InsertChildNode(pCloneNext);
   pNext = pNext->m_pNext;
   while (pNext) {
     CFDE_XMLNode* pChild = pNext->Clone(TRUE);
-    pCloneNext->InsertNodeItem(IFDE_XMLNode::NextSibling, pChild);
+    pCloneNext->InsertNodeItem(CFDE_XMLNode::NextSibling, pChild);
     pCloneNext = pChild;
     pNext = pNext->m_pNext;
   }
 }
-IFDE_XMLInstruction* IFDE_XMLInstruction::Create(
-    const CFX_WideString& wsTarget) {
-  return (IFDE_XMLInstruction*)new CFDE_XMLInstruction(wsTarget);
-}
+
 CFDE_XMLInstruction::CFDE_XMLInstruction(const CFX_WideString& wsTarget)
     : m_wsTarget(wsTarget) {
   FXSYS_assert(m_wsTarget.GetLength() > 0);
 }
 CFDE_XMLNode* CFDE_XMLInstruction::Clone(FX_BOOL bRecursive) {
   CFDE_XMLInstruction* pClone = new CFDE_XMLInstruction(m_wsTarget);
   if (!pClone) {
     return pClone;
   }
   pClone->m_Attributes.Copy(m_Attributes);
@@ skipping 108 matching lines @@
   }
   wsData = m_TargetData[index];
   return TRUE;
 }
 void CFDE_XMLInstruction::AppendData(const CFX_WideString& wsData) {
   m_TargetData.Add(wsData);
 }
 void CFDE_XMLInstruction::RemoveData(int32_t index) {
   m_TargetData.RemoveAt(index);
 }
-IFDE_XMLElement* IFDE_XMLElement::Create(const CFX_WideString& wsTag) {
-  return (IFDE_XMLElement*)new CFDE_XMLElement(wsTag);
-}
+
 CFDE_XMLElement::CFDE_XMLElement(const CFX_WideString& wsTag)
     : CFDE_XMLNode(), m_wsTag(wsTag), m_Attributes() {
   FXSYS_assert(m_wsTag.GetLength() > 0);
 }
 CFDE_XMLElement::~CFDE_XMLElement() {
   m_Attributes.RemoveAll();
 }
 CFDE_XMLNode* CFDE_XMLElement::Clone(FX_BOOL bRecursive) {
   CFDE_XMLElement* pClone = new CFDE_XMLElement(m_wsTag);
   if (!pClone) {
@@ skipping 46 matching lines @@
     wsAttri += wsPrefix;
   }
   wsNamespace.Empty();
   CFDE_XMLNode* pNode = (CFDE_XMLNode*)this;
   while (pNode != NULL) {
     if (pNode->GetType() != FDE_XMLNODE_Element) {
       break;
     }
     CFDE_XMLElement* pElement = (CFDE_XMLElement*)pNode;
     if (!pElement->HasAttribute(wsAttri)) {
-      pNode = pNode->GetNodeItem(IFDE_XMLNode::Parent);
+      pNode = pNode->GetNodeItem(CFDE_XMLNode::Parent);
       continue;
     }
     pElement->GetString(wsAttri, wsNamespace);
     break;
   }
 }
 int32_t CFDE_XMLElement::CountAttributes() const {
   return m_Attributes.GetSize() / 2;
 }
 FX_BOOL CFDE_XMLElement::GetAttribute(int32_t index,
@@ skipping 105 matching lines @@
     pChild = pChild->m_pNext;
   }
   wsText = buffer.GetWideString();
 }
 void CFDE_XMLElement::SetTextData(const CFX_WideString& wsText) {
   if (wsText.GetLength() < 1) {
     return;
   }
   InsertChildNode(new CFDE_XMLText(wsText));
 }
-IFDE_XMLText* IFDE_XMLText::Create(const CFX_WideString& wsText) {
-  return (IFDE_XMLText*)new CFDE_XMLText(wsText);
-}
 CFDE_XMLText::CFDE_XMLText(const CFX_WideString& wsText)
     : CFDE_XMLNode(), m_wsText(wsText) {}
 CFDE_XMLNode* CFDE_XMLText::Clone(FX_BOOL bRecursive) {
   CFDE_XMLText* pClone = new CFDE_XMLText(m_wsText);
   return pClone;
 }
-IFDE_XMLCharData* IFDE_XMLCharData::Create(const CFX_WideString& wsCData) {
-  return (IFDE_XMLCharData*)new CFDE_XMLCharData(wsCData);
-}
+
 CFDE_XMLCharData::CFDE_XMLCharData(const CFX_WideString& wsCData)
     : CFDE_XMLDeclaration(), m_wsCharData(wsCData) {}
 CFDE_XMLNode* CFDE_XMLCharData::Clone(FX_BOOL bRecursive) {
   CFDE_XMLCharData* pClone = new CFDE_XMLCharData(m_wsCharData);
   return pClone;
 }
-IFDE_XMLDoc* IFDE_XMLDoc::Create() {
-  return (IFDE_XMLDoc*)new CFDE_XMLDoc;
-}
+
 CFDE_XMLDoc::CFDE_XMLDoc()
     : m_pRoot(NULL), m_pSyntaxParser(NULL), m_pXMLParser(NULL) {
   Reset(TRUE);
   CFDE_XMLInstruction* pXML = new CFDE_XMLInstruction(L"xml");
   m_pRoot->InsertChildNode(pXML);
 }
 CFDE_XMLDoc::~CFDE_XMLDoc() {
   Reset(FALSE);
 }
 void CFDE_XMLDoc::Reset(FX_BOOL bInitRoot) {
@@ skipping 46 matching lines @@
   iTextDataSize *= 128;
   if (iTextDataSize < 128) {
     iTextDataSize = 128;
   }
   m_pStream = pXMLStream;
   uint16_t wCodePage = m_pStream->GetCodePage();
   if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE &&
       wCodePage != FX_CODEPAGE_UTF8) {
     m_pStream->SetCodePage(FX_CODEPAGE_UTF8);
   }
-  m_pSyntaxParser = IFDE_XMLSyntaxParser::Create();
+  m_pSyntaxParser = new CFDE_XMLSyntaxParser;
   if (m_pSyntaxParser == NULL) {
     return FALSE;
   }
   m_pSyntaxParser->Init(m_pStream, iXMLPlaneSize, iTextDataSize);
   if (pHandler == NULL) {
     m_pXMLParser = new CFDE_XMLDOMParser(m_pRoot, m_pSyntaxParser);
   } else {
     m_pXMLParser = new CFDE_XMLSAXParser(pHandler, m_pSyntaxParser);
   }
   return TRUE;
 }
-FX_BOOL CFDE_XMLDoc::LoadXML(IFDE_XMLParser* pXMLParser) {
+FX_BOOL CFDE_XMLDoc::LoadXML(CFDE_XMLParser* pXMLParser) {
   if (pXMLParser == NULL) {
     return FALSE;
   }
   Reset(TRUE);
   m_pXMLParser = pXMLParser;
   return m_pXMLParser != NULL;
 }
 int32_t CFDE_XMLDoc::DoLoad(IFX_Pause* pPause) {
   if (m_iStatus >= 100) {
     return m_iStatus;
   }
   FXSYS_assert(m_pXMLParser != NULL);
   return m_iStatus = m_pXMLParser->DoParser(pPause);
 }
 void CFDE_XMLDoc::CloseXML() {
   ReleaseParser();
 }
-void CFDE_XMLDoc::SaveXMLNode(IFX_Stream* pXMLStream, IFDE_XMLNode* pINode) {
+void CFDE_XMLDoc::SaveXMLNode(IFX_Stream* pXMLStream, CFDE_XMLNode* pINode) {
   CFDE_XMLNode* pNode = (CFDE_XMLNode*)pINode;
   FXSYS_assert(pXMLStream != NULL && pNode != NULL);
   switch (pNode->GetType()) {
     case FDE_XMLNODE_Instruction: {
       CFX_WideString ws;
       CFDE_XMLInstruction* pInstruction = (CFDE_XMLInstruction*)pNode;
       if (pInstruction->m_wsTarget.CompareNoCase(L"xml") == 0) {
         ws = L"<?xml version=\"1.0\" encoding=\"";
         uint16_t wCodePage = pXMLStream->GetCodePage();
         if (wCodePage == FX_CODEPAGE_UTF16LE) {
@@ skipping 60 matching lines @@
         pXMLStream->WriteString(ws, ws.GetLength());
       }
       if (pNode->m_pChild == NULL) {
         ws = L"\n/>";
         pXMLStream->WriteString(ws, ws.GetLength());
       } else {
         ws = L"\n>";
         pXMLStream->WriteString(ws, ws.GetLength());
         CFDE_XMLNode* pChild = pNode->m_pChild;
         while (pChild != NULL) {
-          SaveXMLNode(pXMLStream, (IFDE_XMLNode*)pChild);
+          SaveXMLNode(pXMLStream, static_cast<CFDE_XMLNode*>(pChild));
           pChild = pChild->m_pNext;
         }
         ws = L"</";
         ws += ((CFDE_XMLElement*)pNode)->m_wsTag;
         ws += L"\n>";
         pXMLStream->WriteString(ws, ws.GetLength());
       }
     } break;
     case FDE_XMLNODE_Text: {
       CFX_WideString ws = ((CFDE_XMLText*)pNode)->m_wsText;
@@ skipping 27 matching lines @@
   if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE &&
       wCodePage != FX_CODEPAGE_UTF8) {
     wCodePage = FX_CODEPAGE_UTF8;
     pXMLStream->SetCodePage(wCodePage);
   }
   if (bSaveBOM) {
     pXMLStream->WriteString(L"\xFEFF", 1);
   }
   CFDE_XMLNode* pNode = m_pRoot->m_pChild;
   while (pNode != NULL) {
-    SaveXMLNode(pXMLStream, (IFDE_XMLNode*)pNode);
+    SaveXMLNode(pXMLStream, static_cast<CFDE_XMLNode*>(pNode));
     pNode = pNode->m_pNext;
   }
   if (pXMLStream == m_pStream) {
     int32_t iPos = pXMLStream->GetPosition();
     pXMLStream->SetLength(iPos);
   }
 }
 CFDE_XMLDOMParser::CFDE_XMLDOMParser(CFDE_XMLNode* pRoot,
-                                     IFDE_XMLSyntaxParser* pParser)
+                                     CFDE_XMLSyntaxParser* pParser)
     : m_pParser(pParser),
       m_pParent(pRoot),
       m_pChild(NULL),
       m_NodeStack(16),
       m_ws1(),
       m_ws2() {
   m_NodeStack.Push(m_pParent);
 }
 CFDE_XMLDOMParser::~CFDE_XMLDOMParser() {
   m_NodeStack.RemoveAll();
@@ skipping 99 matching lines @@
         dwRet == FDE_XMLSYNTAXSTATUS_EOS) {
       break;
     }
     if (pPause != NULL && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return m_pParser->GetStatus();
 }
 CFDE_XMLSAXParser::CFDE_XMLSAXParser(FDE_XMLREADERHANDLER* pHandler,
-                                     IFDE_XMLSyntaxParser* pParser)
+                                     CFDE_XMLSyntaxParser* pParser)
     : m_pHandler(pHandler),
       m_pParser(pParser),
       m_TagStack(16),
       m_pTagTop(NULL),
       m_ws1(),
       m_ws2() {}
 CFDE_XMLSAXParser::~CFDE_XMLSAXParser() {
   m_TagStack.RemoveAll();
   m_ws1.Empty();
   m_ws2.Empty();
@@ skipping 220 matching lines @@
 void CFDE_BlockBuffer::ClearBuffer() {
   m_iBufferSize = 0;
   int32_t iSize = m_BlockArray.GetSize();
   for (int32_t i = 0; i < iSize; i++) {
     FX_Free(m_BlockArray[i]);
     m_BlockArray[i] = NULL;
   }
   m_BlockArray.RemoveAll();
 }
 
-IFDE_XMLSyntaxParser* IFDE_XMLSyntaxParser::Create() {
-  return new CFDE_XMLSyntaxParser;
-}
-
 CFDE_XMLSyntaxParser::CFDE_XMLSyntaxParser()
     : m_pStream(nullptr),
       m_iXMLPlaneSize(-1),
       m_iCurrentPos(0),
       m_iCurrentNodeNum(-1),
       m_iLastNodeNum(-1),
       m_iParsedChars(0),
       m_iParsedBytes(0),
       m_pBuffer(nullptr),
       m_iBufferChars(0),
@@ skipping 625 matching lines @@
     m_BlockBuffer.DeleteTextChars(m_iDataLength - m_iEntityStart, FALSE);
     m_pCurrentBlock = m_BlockBuffer.GetAvailableBlock(m_iIndexInBlock);
     m_iEntityStart = -1;
   } else {
     if (m_iEntityStart < 0 && ch == L'&') {
       m_iEntityStart = m_iDataLength - 1;
     }
   }
   m_pStart++;
 }