Refcount all the IFX_ stream classes all the time.

xfa/fxfa/app/xfa_ffdoc.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/xfa_ffdoc.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 134 matching lines @@
     }
   }
   return pDstEnd - pDst;
 }
 
 }  // namespace
 
 CXFA_FFDoc::CXFA_FFDoc(CXFA_FFApp* pApp, IXFA_DocEnvironment* pDocEnvironment)
     : m_pDocEnvironment(pDocEnvironment),
       m_pDocumentParser(nullptr),
-      m_pStream(nullptr),
       m_pApp(pApp),
       m_pNotify(nullptr),
       m_pPDFDoc(nullptr),
-      m_dwDocType(XFA_DOCTYPE_Static),
-      m_bOwnStream(true) {}
+      m_dwDocType(XFA_DOCTYPE_Static) {}
 
 CXFA_FFDoc::~CXFA_FFDoc() {
   CloseDoc();
 }
 
 uint32_t CXFA_FFDoc::GetDocType() {
   return m_dwDocType;
 }
 
 int32_t CXFA_FFDoc::StartLoad() {
@@ skipping 114 matching lines @@
       return pair.second.get();
   }
   return nullptr;
 }
 
 CXFA_FFDocView* CXFA_FFDoc::GetDocView() {
   auto it = m_TypeToDocViewMap.begin();
   return it != m_TypeToDocViewMap.end() ? it->second.get() : nullptr;
 }
 
-bool CXFA_FFDoc::OpenDoc(IFX_SeekableReadStream* pStream, bool bTakeOverFile) {
-  m_bOwnStream = bTakeOverFile;
+bool CXFA_FFDoc::OpenDoc(const CFX_RetainPtr<IFX_SeekableReadStream>& pStream) {
   m_pStream = pStream;
   return true;
 }
 bool CXFA_FFDoc::OpenDoc(CPDF_Document* pPDFDoc) {
   if (!pPDFDoc)
     return false;
 
   CPDF_Dictionary* pRoot = pPDFDoc->GetRoot();
   if (!pRoot)
     return false;
@@ skipping 12 matching lines @@
     for (size_t i = 0; i < pXFAArray->GetCount() / 2; i++) {
       if (CPDF_Stream* pStream = pXFAArray->GetStreamAt(i * 2 + 1))
         xfaStreams.push_back(pStream);
     }
   } else if (pElementXFA->IsStream()) {
     xfaStreams.push_back((CPDF_Stream*)pElementXFA);
   }
   if (xfaStreams.empty())
     return false;
 
-  IFX_SeekableReadStream* pFileRead = MakeSeekableReadStream(xfaStreams);
   m_pPDFDoc = pPDFDoc;
-  if (m_pStream) {
-    m_pStream->Release();
-    m_pStream = nullptr;
-  }
-  m_pStream = pFileRead;
-  m_bOwnStream = true;
+  m_pStream = MakeSeekableReadStream(xfaStreams);
   return true;
 }
 
 bool CXFA_FFDoc::CloseDoc() {
   for (const auto& pair : m_TypeToDocViewMap)
     pair.second->RunDocClose();
 
   CXFA_Document* doc =
       m_pDocumentParser ? m_pDocumentParser->GetDocument() : nullptr;
   if (doc)
     doc->ClearLayoutData();
 
   m_TypeToDocViewMap.clear();
 
   m_pNotify.reset(nullptr);
   m_pApp->GetXFAFontMgr()->ReleaseDocFonts(this);
 
-  if (m_dwDocType != XFA_DOCTYPE_XDP && m_pStream && m_bOwnStream) {
-    m_pStream->Release();
-    m_pStream = nullptr;
-  }
-
   for (const auto& pair : m_HashToDibDpiMap)
     delete pair.second.pDibSource;
 
   m_HashToDibDpiMap.clear();
   m_pApp->ClearEventTargets();
   return true;
 }
 void CXFA_FFDoc::SetDocType(uint32_t dwType) {
   m_dwDocType = dwType;
 }
@@ skipping 41 matching lines @@
     }
   }
 
   CPDF_Stream* pStream = ToStream(pObject);
   if (!pStream)
     return nullptr;
 
   CPDF_StreamAcc streamAcc;
   streamAcc.LoadAllData(pStream);
 
-  IFX_SeekableReadStream* pImageFileRead = IFX_MemoryStream::Create(
-      (uint8_t*)streamAcc.GetData(), streamAcc.GetSize());
+  CFX_RetainPtr<IFX_SeekableReadStream> pImageFileRead =
+      IFX_MemoryStream::Create((uint8_t*)streamAcc.GetData(),
+                               streamAcc.GetSize());
 
   CFX_DIBitmap* pDibSource = XFA_LoadImageFromBuffer(
       pImageFileRead, FXCODEC_IMAGE_UNKNOWN, iImageXDpi, iImageYDpi);
   m_HashToDibDpiMap[dwHash] = {pDibSource, iImageXDpi, iImageYDpi};
-  pImageFileRead->Release();
   return pDibSource;
 }
 
-bool CXFA_FFDoc::SavePackage(XFA_HashCode code,
-                             IFX_SeekableWriteStream* pFile,
-                             CXFA_ChecksumContext* pCSContext) {
+bool CXFA_FFDoc::SavePackage(
+    XFA_HashCode code,
+    const CFX_RetainPtr<IFX_SeekableWriteStream>& pFile,
+    CXFA_ChecksumContext* pCSContext) {
   CXFA_Document* doc = m_pDocumentParser->GetDocument();
-
   std::unique_ptr<CXFA_DataExporter> pExport(new CXFA_DataExporter(doc));
   CXFA_Node* pNode = code == XFA_HASHCODE_Xfa ? doc->GetRoot()
                                               : ToNode(doc->GetXFAObject(code));
   if (!pNode)
     return !!pExport->Export(pFile);
 
   CFX_ByteString bsChecksum;
   if (pCSContext)
     bsChecksum = pCSContext->GetChecksum();
 
   return !!pExport->Export(
       pFile, pNode, 0, bsChecksum.GetLength() ? bsChecksum.c_str() : nullptr);
 }
 
-bool CXFA_FFDoc::ImportData(IFX_SeekableReadStream* pStream, bool bXDP) {
-  std::unique_ptr<CXFA_DataImporter> importer(
-      new CXFA_DataImporter(m_pDocumentParser->GetDocument()));
+bool CXFA_FFDoc::ImportData(
+    const CFX_RetainPtr<IFX_SeekableReadStream>& pStream,
+    bool bXDP) {
+  auto importer =
+      pdfium::MakeUnique<CXFA_DataImporter>(m_pDocumentParser->GetDocument());
   return importer->ImportData(pStream);
 }