Cleanup ownership of parser members

xfa/fxfa/parser/cxfa_simple_parser.cpp

 // Copyright 2016 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/cxfa_simple_parser.h"
 
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fxfa/include/fxfa.h"
 #include "xfa/fxfa/include/xfa_checksum.h"
 #include "xfa/fxfa/parser/cxfa_xml_parser.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 
 CXFA_SimpleParser::CXFA_SimpleParser(CXFA_Document* pFactory,
                                      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::SetFactory(CXFA_Document* pFactory) {
   m_pFactory = pFactory;
 }
 
 static CFDE_XMLNode* XFA_FDEExtension_GetDocumentNode(
     CFDE_XMLDoc* pXMLDoc,
     FX_BOOL bVerifyWellFormness = FALSE) {
   if (!pXMLDoc) {
@@ skipping 12 matching lines @@
           if (pNextNode->GetType() == FDE_XMLNODE_Element) {
             return FALSE;
           }
         }
       }
       return pXMLNode;
     }
   }
   return nullptr;
 }
+
 int32_t CXFA_SimpleParser::StartParse(IFX_FileRead* pStream,
                                       XFA_XDPPACKET ePacketID) {
   CloseParser();
   m_pFileRead = pStream;
-  m_pStream = IFX_Stream::CreateStream(
-      pStream, FX_STREAMACCESS_Read | FX_STREAMACCESS_Text);
-  if (!m_pStream) {
+  m_pStream.reset(IFX_Stream::CreateStream(
+      pStream, FX_STREAMACCESS_Read | FX_STREAMACCESS_Text));
+  if (!m_pStream)
     return XFA_PARSESTATUS_StreamErr;
-  }
+
   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_pXMLDoc = new CFDE_XMLDoc;
-  m_pXMLParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
-  if (!m_pXMLDoc->LoadXML(m_pXMLParser)) {
+  m_pXMLDoc.reset(new CFDE_XMLDoc);
+  m_pXMLParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream.get());
+  if (!m_pXMLDoc->LoadXML(m_pXMLParser))
     return XFA_PARSESTATUS_StatusErr;
-  }
+
   m_ePacketID = ePacketID;
   return XFA_PARSESTATUS_Ready;
 }
+
 int32_t CXFA_SimpleParser::DoParse(IFX_Pause* pPause) {
-  if (!m_pXMLDoc || m_ePacketID == XFA_XDPPACKET_UNKNOWN) {
+  if (!m_pXMLDoc || m_ePacketID == XFA_XDPPACKET_UNKNOWN)
     return XFA_PARSESTATUS_StatusErr;
-  }
+
   int32_t iRet = m_pXMLDoc->DoLoad(pPause);
-  if (iRet < 0) {
+  if (iRet < 0)
     return XFA_PARSESTATUS_SyntaxErr;
-  }
-  if (iRet < 100) {
+  if (iRet < 100)
     return iRet / 2;
-  }
-  m_pRootNode = ParseAsXDPPacket(XFA_FDEExtension_GetDocumentNode(m_pXMLDoc),
-                                 m_ePacketID);
+
+  m_pRootNode = ParseAsXDPPacket(
+      XFA_FDEExtension_GetDocumentNode(m_pXMLDoc.get()), m_ePacketID);
   m_pXMLDoc->CloseXML();
-  if (m_pStream) {
-    m_pStream->Release();
-    m_pStream = nullptr;
-  }
-  if (!m_pRootNode) {
+  m_pStream.reset();
+
+  if (!m_pRootNode)
     return XFA_PARSESTATUS_StatusErr;
-  }
   return XFA_PARSESTATUS_Done;
 }
+
 int32_t CXFA_SimpleParser::ParseXMLData(const CFX_WideString& wsXML,
                                         CFDE_XMLNode*& pXMLNode,
                                         IFX_Pause* pPause) {
   CloseParser();
   pXMLNode = nullptr;
-  IFX_Stream* pStream = XFA_CreateWideTextRead(wsXML);
-  if (!pStream) {
+
+  std::unique_ptr<IFX_Stream> pStream(XFA_CreateWideTextRead(wsXML));
+  if (!pStream)
     return XFA_PARSESTATUS_StreamErr;
-  }
-  m_pStream = pStream;
-  m_pXMLDoc = new CFDE_XMLDoc;
-  CXFA_XMLParser* pParser = new CXFA_XMLParser(m_pXMLDoc->GetRoot(), m_pStream);
+
+  m_pXMLDoc.reset(new CFDE_XMLDoc);
+  CXFA_XMLParser* pParser =
+      new CXFA_XMLParser(m_pXMLDoc->GetRoot(), pStream.get());
   pParser->m_dwCheckStatus = 0x03;
-  if (!m_pXMLDoc->LoadXML(pParser)) {
+  if (!m_pXMLDoc->LoadXML(pParser))
     return XFA_PARSESTATUS_StatusErr;
-  }
+
   int32_t iRet = m_pXMLDoc->DoLoad(pPause);
-  if (iRet < 0 || iRet >= 100) {
+  if (iRet < 0 || iRet >= 100)
     m_pXMLDoc->CloseXML();
-  }
-  if (iRet < 0) {
+  if (iRet < 0)
     return XFA_PARSESTATUS_SyntaxErr;
-  }
-  if (iRet < 100) {
+  if (iRet < 100)
     return iRet / 2;
-  }
-  if (m_pStream) {
-    m_pStream->Release();
-    m_pStream = nullptr;
-  }
-  pXMLNode = XFA_FDEExtension_GetDocumentNode(m_pXMLDoc);
+
+  pXMLNode = XFA_FDEExtension_GetDocumentNode(m_pXMLDoc.get());
   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->GetElementType() == XFA_Element::DataValue) {
       for (CFDE_XMLNode* pXMLChild =
                pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
@@ skipping 34 matching lines @@
   } else {
     m_pRootNode = NormalLoader(pXFANode, pXMLNode, ePacketID);
   }
 }
 
 CXFA_Node* CXFA_SimpleParser::GetRootNode() const {
   return m_pRootNode;
 }
 
 CFDE_XMLDoc* CXFA_SimpleParser::GetXMLDoc() const {
-  return m_pXMLDoc;
+  return m_pXMLDoc.get();
 }
 
 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);
@@ skipping 11 matching lines @@
       continue;
     }
     if (pNode->HasAttribute(wsNSAttribute.c_str())) {
       pNode->GetString(wsNSAttribute.c_str(), wsNamespaceURI);
       return TRUE;
     }
   }
   wsNamespaceURI.clear();
   return bRet;
 }
+
 static inline void XFA_FDEExtension_GetElementTagNamespaceURI(
     CFDE_XMLElement* pElement,
     CFX_WideString& wsNamespaceURI) {
   CFX_WideString wsNodeStr;
   pElement->GetNamespacePrefix(wsNodeStr);
   if (!XFA_FDEExtension_ResolveNamespaceQualifier(
           pElement, wsNodeStr.AsStringC(), wsNamespaceURI)) {
     wsNamespaceURI.clear();
   }
 }
+
 static FX_BOOL XFA_FDEExtension_MatchNodeName(
     CFDE_XMLNode* pNode,
     const CFX_WideStringC& wsLocalTagName,
     const CFX_WideStringC& wsNamespaceURIPrefix,
     uint32_t eMatchFlags = XFA_XDPPACKET_FLAGS_NOMATCH) {
   if (!pNode || pNode->GetType() != FDE_XMLNODE_Element) {
     return FALSE;
   }
   CFDE_XMLElement* pElement = reinterpret_cast<CFDE_XMLElement*>(pNode);
   CFX_WideString wsNodeStr;
   pElement->GetLocalTagName(wsNodeStr);
   if (wsNodeStr != wsLocalTagName) {
     return FALSE;
   }
   XFA_FDEExtension_GetElementTagNamespaceURI(pElement, wsNodeStr);
   if (eMatchFlags & XFA_XDPPACKET_FLAGS_NOMATCH) {
     return TRUE;
   }
   if (eMatchFlags & XFA_XDPPACKET_FLAGS_PREFIXMATCH) {
     return wsNodeStr.Left(wsNamespaceURIPrefix.GetLength()) ==
            wsNamespaceURIPrefix;
   }
   return wsNodeStr == wsNamespaceURIPrefix;
 }
+
 static FX_BOOL XFA_FDEExtension_GetAttributeLocalName(
     const CFX_WideStringC& wsAttributeName,
     CFX_WideString& wsLocalAttrName) {
   CFX_WideString wsAttrName(wsAttributeName);
   FX_STRSIZE iFind = wsAttrName.Find(L':', 0);
   if (iFind < 0) {
     wsLocalAttrName = wsAttrName;
     return FALSE;
   } else {
     wsLocalAttrName = wsAttrName.Right(wsAttrName.GetLength() - iFind - 1);
     return TRUE;
   }
 }
+
 static FX_BOOL XFA_FDEExtension_ResolveAttribute(
     CFDE_XMLElement* pElement,
     const CFX_WideStringC& wsAttributeName,
     CFX_WideString& wsLocalAttrName,
     CFX_WideString& wsNamespaceURI) {
   CFX_WideString wsAttrName(wsAttributeName);
   CFX_WideString wsNSPrefix;
   if (XFA_FDEExtension_GetAttributeLocalName(wsAttributeName,
                                              wsLocalAttrName)) {
     wsNSPrefix = wsAttrName.Left(wsAttributeName.GetLength() -
                                  wsLocalAttrName.GetLength() - 1);
   }
   if (wsLocalAttrName == FX_WSTRC(L"xmlns") ||
       wsNSPrefix == FX_WSTRC(L"xmlns") || wsNSPrefix == FX_WSTRC(L"xml")) {
     return FALSE;
   }
   if (!XFA_FDEExtension_ResolveNamespaceQualifier(
           pElement, wsNSPrefix.AsStringC(), wsNamespaceURI)) {
     wsNamespaceURI.clear();
     return FALSE;
   }
   return TRUE;
 }
+
 static FX_BOOL XFA_FDEExtension_FindAttributeWithNS(
     CFDE_XMLElement* pElement,
     const CFX_WideStringC& wsLocalAttributeName,
     const CFX_WideStringC& wsNamespaceURIPrefix,
     CFX_WideString& wsValue,
     FX_BOOL bMatchNSAsPrefix = FALSE) {
   if (!pElement) {
     return FALSE;
   }
   CFX_WideString wsAttrName;
@@ skipping 27 matching lines @@
     } else {
       if (wsAttrNS != wsNamespaceURIPrefix) {
         continue;
       }
     }
     wsValue = wsAttrValue;
     return TRUE;
   }
   return FALSE;
 }
+
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket(CFDE_XMLNode* pXMLDocumentNode,
                                                XFA_XDPPACKET ePacketID) {
   switch (ePacketID) {
     case XFA_XDPPACKET_UNKNOWN:
       return nullptr;
     case XFA_XDPPACKET_XDP:
       return ParseAsXDPPacket_XDP(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_Config:
       return ParseAsXDPPacket_Config(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_Template:
     case XFA_XDPPACKET_Form:
       return ParseAsXDPPacket_TemplateForm(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_Datasets:
       return ParseAsXDPPacket_Data(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_Xdc:
       return ParseAsXDPPacket_Xdc(pXMLDocumentNode, ePacketID);
     case XFA_XDPPACKET_LocaleSet:
     case XFA_XDPPACKET_ConnectionSet:
     case XFA_XDPPACKET_SourceSet:
       return ParseAsXDPPacket_LocaleConnectionSourceSet(pXMLDocumentNode,
                                                         ePacketID);
     default:
       return ParseAsXDPPacket_User(pXMLDocumentNode, ePacketID);
   }
 }
+
 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 =
@@ skipping 118 matching lines @@
   if (pXMLFormDOMRoot) {
     CXFA_Node* pPacketNode =
         ParseAsXDPPacket(pXMLFormDOMRoot, XFA_XDPPACKET_Form);
     if (pPacketNode) {
       pXFARootNode->InsertChild(pPacketNode);
     }
   }
   pXFARootNode->SetXMLMappingNode(pXMLDocumentNode);
   return pXFARootNode;
 }
+
 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 nullptr;
   }
   CXFA_Node* pNode =
       m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_Element::Config);
   if (!pNode) {
     return nullptr;
   }
   pNode->SetCData(XFA_ATTRIBUTE_Name,
                   XFA_GetPacketByIndex(XFA_PACKET_Config)->pName);
   if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
     return nullptr;
   }
   pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
+
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_TemplateForm(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = nullptr;
   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 =
@@ skipping 63 matching lines @@
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, bUseAttribute)) {
         return nullptr;
       }
     }
   }
   if (pNode) {
     pNode->SetXMLMappingNode(pXMLDocumentNode);
   }
   return pNode;
 }
+
 static CFDE_XMLNode* XFA_GetDataSetsFromXDP(CFDE_XMLNode* pXMLDocumentNode) {
   if (XFA_FDEExtension_MatchNodeName(
           pXMLDocumentNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName,
           XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
           XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
     return pXMLDocumentNode;
   }
   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;
   }
   for (CFDE_XMLNode* pDatasetsNode =
            pXMLDocumentNode->GetNodeItem(CFDE_XMLNode::FirstChild);
        pDatasetsNode;
        pDatasetsNode = pDatasetsNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     if (!XFA_FDEExtension_MatchNodeName(
             pDatasetsNode, XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pName,
             XFA_GetPacketByIndex(XFA_PACKET_Datasets)->pURI,
             XFA_GetPacketByIndex(XFA_PACKET_Datasets)->eFlags)) {
       continue;
     }
     return pDatasetsNode;
   }
   return nullptr;
 }
+
 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);
     if (!pNode) {
       return nullptr;
     }
@@ skipping 44 matching lines @@
       return nullptr;
     }
     pNode->SetXMLMappingNode(pDataXMLNode);
     if (pDataXMLNode != pXMLDocumentNode) {
       pNode->SetFlag(XFA_NodeFlag_OwnXMLNode, false);
     }
     return pNode;
   }
   return nullptr;
 }
+
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = nullptr;
   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,
@@ skipping 39 matching lines @@
       if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID)) {
         return nullptr;
       }
     }
   }
   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);
     if (!pNode) {
       return nullptr;
     }
     pNode->SetCData(XFA_ATTRIBUTE_Name,
                     XFA_GetPacketByIndex(XFA_PACKET_Xdc)->pName);
     pNode->SetXMLMappingNode(pXMLDocumentNode);
     return pNode;
   }
   return nullptr;
 }
+
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_User(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode =
       m_pFactory->CreateNode(XFA_XDPPACKET_XDP, XFA_Element::Packet);
   if (!pNode) {
     return nullptr;
   }
   CFX_WideString wsName;
   static_cast<CFDE_XMLElement*>(pXMLDocumentNode)->GetLocalTagName(wsName);
   pNode->SetCData(XFA_ATTRIBUTE_Name, wsName);
   if (!UserPacketLoader(pNode, pXMLDocumentNode)) {
     return nullptr;
   }
   pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
+
 CXFA_Node* CXFA_SimpleParser::UserPacketLoader(CXFA_Node* pXFANode,
                                                CFDE_XMLNode* pXMLDoc) {
   return pXFANode;
 }
+
 static FX_BOOL XFA_FDEExtension_IsStringAllWhitespace(CFX_WideString wsText) {
   wsText.TrimRight(L"\x20\x9\xD\xA");
   return wsText.IsEmpty();
 }
+
 CXFA_Node* CXFA_SimpleParser::DataLoader(CXFA_Node* pXFANode,
                                          CFDE_XMLNode* pXMLDoc,
                                          FX_BOOL bDoTransform) {
   ParseDataGroup(pXFANode, pXMLDoc, XFA_XDPPACKET_Datasets);
   return pXFANode;
 }
+
 CXFA_Node* CXFA_SimpleParser::NormalLoader(CXFA_Node* pXFANode,
                                            CFDE_XMLNode* pXMLDoc,
                                            XFA_XDPPACKET ePacketID,
                                            FX_BOOL bUseAttribute) {
   FX_BOOL bOneOfPropertyFound = FALSE;
   for (CFDE_XMLNode* pXMLChild = pXMLDoc->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
        pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     switch (pXMLChild->GetType()) {
       case FDE_XMLNODE_Element: {
@@ skipping 70 matching lines @@
       case FDE_XMLNODE_Instruction:
         ParseInstruction(pXFANode, static_cast<CFDE_XMLInstruction*>(pXMLChild),
                          ePacketID);
         break;
       default:
         break;
     }
   }
   return pXFANode;
 }
+
 FX_BOOL XFA_RecognizeRichText(CFDE_XMLElement* pRichTextXMLNode) {
   if (pRichTextXMLNode) {
     CFX_WideString wsNamespaceURI;
     XFA_FDEExtension_GetElementTagNamespaceURI(pRichTextXMLNode,
                                                wsNamespaceURI);
     if (wsNamespaceURI == FX_WSTRC(L"http://www.w3.org/1999/xhtml")) {
       return TRUE;
     }
   }
   return FALSE;
 }
+
 class RichTextNodeVisitor {
  public:
   static inline CFDE_XMLNode* GetFirstChild(CFDE_XMLNode* pNode) {
     return pNode->GetNodeItem(CFDE_XMLNode::FirstChild);
   }
   static inline CFDE_XMLNode* GetNextSibling(CFDE_XMLNode* pNode) {
     return pNode->GetNodeItem(CFDE_XMLNode::NextSibling);
   }
   static inline CFDE_XMLNode* GetParent(CFDE_XMLNode* pNode) {
     return pNode->GetNodeItem(CFDE_XMLNode::Parent);
@@ skipping 381 matching lines @@
     CFX_WideString wsData;
     if (pXMLInstruction->GetData(0, wsData) &&
         wsData == FX_WSTRC(L"JavaScript")) {
       if (pXMLInstruction->GetData(1, wsData) &&
           wsData == FX_WSTRC(L"strictScoping")) {
         pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_StrictScoping, TRUE);
       }
     }
   }
 }
+
 void CXFA_SimpleParser::CloseParser() {
-  if (m_pXMLDoc) {
-    m_pXMLDoc->Release();
-    m_pXMLDoc = nullptr;
-  }
-  if (m_pStream) {
-    m_pStream->Release();
-    m_pStream = nullptr;
-  }
+  m_pXMLDoc.reset();
+  m_pStream.reset();
 }