Make code compile with clang_use_chrome_plugin (part V)

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 19 matching lines @@
       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 NULL;
   }
   CFDE_XMLNode* pXMLFakeRoot = pXMLDoc->GetRoot();
@@ skipping 134 matching lines @@
       m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE);
     }
   } else if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
     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,
     const CFX_WideStringC& wsQualifier,
     CFX_WideString& wsNamespaceURI) {
   if (!pNode) {
     return FALSE;
   }
   CFDE_XMLNode* pFakeRoot = pNode->GetNodeItem(CFDE_XMLNode::Root);
   CFX_WideString wsNSAttribute;
   FX_BOOL bRet = FALSE;
@@ skipping 1136 matching lines @@
     m_pStream->Release();
     m_pStream = NULL;
   }
 }
 
 CXFA_DocumentParser::CXFA_DocumentParser(CXFA_FFNotify* pNotify)
     : m_nodeParser(NULL, TRUE), m_pNotify(pNotify), m_pDocument(NULL) {}
 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);
   }
   return nRetStatus;
 }
@@ skipping 21 matching lines @@
   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;
+}
+
 void CXFA_DocumentParser::CloseParser() {
   delete m_pDocument;
   m_pDocument = nullptr;
   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),
       m_pParent(pRoot),
       m_pChild(nullptr),
       m_NodeStack(16),
       m_syntaxParserResult(FDE_XmlSyntaxResult::None) {
   ASSERT(m_pParent && m_pStream);
   m_NodeStack.Push(m_pParent);
   m_pParser = new CFDE_XMLSyntaxParser;
   m_pParser->Init(m_pStream, 32 * 1024, 1024 * 1024);
 }
+
 CXFA_XMLParser::~CXFA_XMLParser() {
   if (m_pParser) {
     m_pParser->Release();
   }
   m_NodeStack.RemoveAll();
   m_ws1.clear();
   m_ws2.clear();
 }
+
+void CXFA_XMLParser::Release() {
+  delete this;
+}
+
 int32_t CXFA_XMLParser::DoParser(IFX_Pause* pPause) {
   if (m_syntaxParserResult == FDE_XmlSyntaxResult::Error)
     return -1;
   if (m_syntaxParserResult == FDE_XmlSyntaxResult::EndOfString)
     return 100;
 
   int32_t iCount = 0;
   while (TRUE) {
     m_syntaxParserResult = m_pParser->DoSyntaxParse();
     switch (m_syntaxParserResult) {
@@ skipping 122 matching lines @@
     }
     if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return (m_syntaxParserResult == FDE_XmlSyntaxResult::Error ||
           m_NodeStack.GetSize() != 1)
              ? -1
              : m_pParser->GetStatus();
 }