Remove IXFA_Parser, cleanup XFA parser code.

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>
 
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fxfa/include/xfa_checksum.h"
 #include "xfa/fxfa/parser/xfa_basic_imp.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_localemgr.h"
 #include "xfa/fxfa/parser/xfa_object.h"
-#include "xfa/fxfa/parser/xfa_parser.h"
 #include "xfa/fxfa/parser/xfa_script.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
 
-IXFA_Parser* IXFA_Parser::Create(CXFA_Document* pFactory,
-                                 FX_BOOL bDocumentParser) {
-  return new CXFA_SimpleParser(pFactory, bDocumentParser);
-}
 CXFA_SimpleParser::CXFA_SimpleParser(CXFA_Document* pFactory,
-                                     FX_BOOL bDocumentParser)
+                                     bool bDocumentParser)
     : m_pXMLParser(nullptr),
       m_pXMLDoc(nullptr),
       m_pStream(nullptr),
       m_pFileRead(nullptr),
       m_pFactory(pFactory),
       m_pRootNode(nullptr),
       m_ePacketID(XFA_XDPPACKET_UNKNOWN),
       m_bDocumentParser(bDocumentParser) {}
+
 CXFA_SimpleParser::~CXFA_SimpleParser() {
   CloseParser();
 }
-void CXFA_SimpleParser::Release() {
-  delete this;
-}
+
 void CXFA_SimpleParser::SetFactory(CXFA_Document* pFactory) {
   m_pFactory = pFactory;
 }
+
 static CFDE_XMLNode* XFA_FDEExtension_GetDocumentNode(
     CFDE_XMLDoc* pXMLDoc,
     FX_BOOL bVerifyWellFormness = FALSE) {
   if (!pXMLDoc) {
     return nullptr;
   }
   CFDE_XMLNode* pXMLFakeRoot = pXMLDoc->GetRoot();
   for (CFDE_XMLNode* pXMLNode =
            pXMLFakeRoot->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLNode; pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
@@ skipping 131 matching lines @@
       m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE);
     }
   } 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;
-}
-
 CXFA_Node* CXFA_SimpleParser::GetRootNode() const {
   return m_pRootNode;
 }
 
 CFDE_XMLDoc* CXFA_SimpleParser::GetXMLDoc() const {
   return m_pXMLDoc;
 }
 
 FX_BOOL XFA_FDEExtension_ResolveNamespaceQualifier(
     CFDE_XMLElement* pNode,
@@ skipping 1117 matching lines @@
     m_pXMLDoc = nullptr;
   }
   if (m_pStream) {
     m_pStream->Release();
     m_pStream = nullptr;
   }
 }
 
 CXFA_DocumentParser::CXFA_DocumentParser(CXFA_FFNotify* pNotify)
     : m_nodeParser(nullptr, TRUE), m_pNotify(pNotify), m_pDocument(nullptr) {}
+
 CXFA_DocumentParser::~CXFA_DocumentParser() {
   CloseParser();
 }
 
-void CXFA_DocumentParser::Release() {
-  delete this;
-}
 int32_t CXFA_DocumentParser::StartParse(IFX_FileRead* pStream,
                                         XFA_XDPPACKET ePacketID) {
   CloseParser();
   int32_t nRetStatus = m_nodeParser.StartParse(pStream, ePacketID);
   if (nRetStatus == XFA_PARSESTATUS_Ready) {
-    m_pDocument = new CXFA_Document(this);
-    m_nodeParser.SetFactory(m_pDocument);
+    m_pDocument.reset(new CXFA_Document(this));
+    m_nodeParser.SetFactory(m_pDocument.get());
   }
   return nRetStatus;
 }
+
 int32_t CXFA_DocumentParser::DoParse(IFX_Pause* pPause) {
   int32_t nRetStatus = m_nodeParser.DoParse(pPause);
   if (nRetStatus >= XFA_PARSESTATUS_Done) {
     ASSERT(m_pDocument);
     m_pDocument->SetRoot(m_nodeParser.GetRootNode());
   }
   return nRetStatus;
 }
-int32_t CXFA_DocumentParser::ParseXMLData(const CFX_WideString& wsXML,
-                                          CFDE_XMLNode*& pXMLNode,
-                                          IFX_Pause* pPause) {
-  CloseParser();
-  int32_t nRetStatus = m_nodeParser.ParseXMLData(wsXML, pXMLNode, nullptr);
-  if (nRetStatus == XFA_PARSESTATUS_Done && pXMLNode) {
-    m_pDocument = new CXFA_Document(this);
-    m_nodeParser.SetFactory(m_pDocument);
-  }
-  return nRetStatus;
-}
-void CXFA_DocumentParser::ConstructXFANode(CXFA_Node* pXFANode,
-                                           CFDE_XMLNode* pXMLNode) {
-  if (!pXFANode || !pXMLNode) {
-    return;
-  }
-  m_nodeParser.ConstructXFANode(pXFANode, pXMLNode);
-  CXFA_Node* pRootNode = m_nodeParser.GetRootNode();
-  if (m_pDocument && pRootNode) {
-    m_pDocument->SetRoot(pRootNode);
-  }
-}
-
-CXFA_Document* CXFA_DocumentParser::GetFactory() const {
-  return m_nodeParser.GetFactory();
-}
-
-CXFA_Node* CXFA_DocumentParser::GetRootNode() const {
-  return m_nodeParser.GetRootNode();
-}
 
 CFDE_XMLDoc* CXFA_DocumentParser::GetXMLDoc() const {
   return m_nodeParser.GetXMLDoc();
 }
 
 CXFA_FFNotify* CXFA_DocumentParser::GetNotify() const {
   return m_pNotify;
 }
 
 CXFA_Document* CXFA_DocumentParser::GetDocument() const {
-  return m_pDocument;
+  return m_pDocument.get();
 }
 
 void CXFA_DocumentParser::CloseParser() {
-  delete m_pDocument;
-  m_pDocument = nullptr;
+  m_pDocument.reset();
   m_nodeParser.CloseParser();
 }
 
 CXFA_XMLParser::CXFA_XMLParser(CFDE_XMLNode* pRoot, IFX_Stream* pStream)
     : m_nElementStart(0),
       m_dwCheckStatus(0),
       m_dwCurrentCheckStatus(0),
       m_pRoot(pRoot),
       m_pStream(pStream),
       m_pParser(nullptr),
@@ skipping 155 matching lines @@
     }
     if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return (m_syntaxParserResult == FDE_XmlSyntaxResult::Error ||
           m_NodeStack.GetSize() != 1)
              ? -1
              : m_pParser->GetStatus();
 }