Catch stray Retains() and Releases() outside of RetainPtr<>.

core/fxcrt/fx_extension.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 "core/fxcrt/extension.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 56 matching lines @@
 bool CFX_CRTFileAccess::Init(const CFX_WideStringC& wsPath) {
   m_path = wsPath;
   m_RefCount = 1;
   return true;
 }
 
 #endif  // PDF_ENABLE_XFA
 
 class CFX_CRTFileStream final : public IFX_SeekableStream {
  public:
-  explicit CFX_CRTFileStream(std::unique_ptr<IFXCRT_FileAccess> pFA);
-  ~CFX_CRTFileStream() override;
+  template <typename T, typename... Args>
+  friend CFX_RetainPtr<T> pdfium::MakeRetain(Args&&... args);
 
   // IFX_SeekableStream:
   FX_FILESIZE GetSize() override;
   bool IsEOF() override;
   FX_FILESIZE GetPosition() override;
   bool ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override;
   size_t ReadBlock(void* buffer, size_t size) override;
   bool WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size) override;
   bool Flush() override;
 
  private:
+  explicit CFX_CRTFileStream(std::unique_ptr<IFXCRT_FileAccess> pFA);
+  ~CFX_CRTFileStream() override;
+
   std::unique_ptr<IFXCRT_FileAccess> m_pFile;
 };
 
 CFX_CRTFileStream::CFX_CRTFileStream(std::unique_ptr<IFXCRT_FileAccess> pFA)
     : m_pFile(std::move(pFA)) {}
 
 CFX_CRTFileStream::~CFX_CRTFileStream() {}
 
 FX_FILESIZE CFX_CRTFileStream::GetSize() {
   return m_pFile->GetSize();
@@ skipping 26 matching lines @@
 bool CFX_CRTFileStream::Flush() {
   return m_pFile->Flush();
 }
 
 #define FX_MEMSTREAM_BlockSize (64 * 1024)
 #define FX_MEMSTREAM_Consecutive 0x01
 #define FX_MEMSTREAM_TakeOver 0x02
 
 class CFX_MemoryStream final : public IFX_MemoryStream {
  public:
-  explicit CFX_MemoryStream(bool bConsecutive);
-  CFX_MemoryStream(uint8_t* pBuffer, size_t nSize, bool bTakeOver);
-  ~CFX_MemoryStream() override;
+  template <typename T, typename... Args>
+  friend CFX_RetainPtr<T> pdfium::MakeRetain(Args&&... args);
 
   // IFX_MemoryStream
   FX_FILESIZE GetSize() override;
   bool IsEOF() override;
   FX_FILESIZE GetPosition() override;
   bool ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override;
   size_t ReadBlock(void* buffer, size_t size) override;
   bool WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size) override;
   bool Flush() override;
   bool IsConsecutive() const override;
   void EstimateSize(size_t nInitSize, size_t nGrowSize) override;
   uint8_t* GetBuffer() const override;
   void AttachBuffer(uint8_t* pBuffer,
                     size_t nSize,
                     bool bTakeOver = false) override;
   void DetachBuffer() override;
 
  private:
+  explicit CFX_MemoryStream(bool bConsecutive);
+  CFX_MemoryStream(uint8_t* pBuffer, size_t nSize, bool bTakeOver);
+  ~CFX_MemoryStream() override;
+
   bool ExpandBlocks(size_t size);
 
   CFX_ArrayTemplate<uint8_t*> m_Blocks;
   size_t m_nTotalSize;
   size_t m_nCurSize;
   size_t m_nCurPos;
   size_t m_nGrowSize;
   uint32_t m_dwFlags;
 };
 
@@ skipping 222 matching lines @@
 }
 #endif  // PDF_ENABLE_XFA
 
 // static
 CFX_RetainPtr<IFX_SeekableStream> IFX_SeekableStream::CreateFromFilename(
     const FX_CHAR* filename,
     uint32_t dwModes) {
   std::unique_ptr<IFXCRT_FileAccess> pFA(IFXCRT_FileAccess::Create());
   if (!pFA->Open(filename, dwModes))
     return nullptr;
-  return CFX_RetainPtr<IFX_SeekableStream>(
-      new CFX_CRTFileStream(std::move(pFA)));
+  return pdfium::MakeRetain<CFX_CRTFileStream>(std::move(pFA));
 }
 
 // static
 CFX_RetainPtr<IFX_SeekableStream> IFX_SeekableStream::CreateFromFilename(
     const FX_WCHAR* filename,
     uint32_t dwModes) {
   std::unique_ptr<IFXCRT_FileAccess> pFA(IFXCRT_FileAccess::Create());
   if (!pFA->Open(filename, dwModes))
     return nullptr;
-  return CFX_RetainPtr<IFX_SeekableStream>(
-      new CFX_CRTFileStream(std::move(pFA)));
+  return pdfium::MakeRetain<CFX_CRTFileStream>(std::move(pFA));
 }
 
 // static
 CFX_RetainPtr<IFX_SeekableReadStream>
 IFX_SeekableReadStream::CreateFromFilename(const FX_CHAR* filename) {
   return IFX_SeekableStream::CreateFromFilename(filename, FX_FILEMODE_ReadOnly);
 }
 
 // static
 CFX_RetainPtr<IFX_MemoryStream> IFX_MemoryStream::Create(uint8_t* pBuffer,
                                                          size_t dwSize,
                                                          bool bTakeOver) {
-  return CFX_RetainPtr<IFX_MemoryStream>(
-      new CFX_MemoryStream(pBuffer, dwSize, bTakeOver));
+  return pdfium::MakeRetain<CFX_MemoryStream>(pBuffer, dwSize, bTakeOver);
 }
 
 // static
 CFX_RetainPtr<IFX_MemoryStream> IFX_MemoryStream::Create(bool bConsecutive) {
-  return CFX_RetainPtr<IFX_MemoryStream>(new CFX_MemoryStream(bConsecutive));
+  return pdfium::MakeRetain<CFX_MemoryStream>(bConsecutive);
 }
 
 FX_FLOAT FXSYS_tan(FX_FLOAT a) {
   return (FX_FLOAT)tan(a);
 }
 FX_FLOAT FXSYS_logb(FX_FLOAT b, FX_FLOAT x) {
   return FXSYS_log(x) / FXSYS_log(b);
 }
 FX_FLOAT FXSYS_strtof(const FX_CHAR* pcsStr,
                       int32_t iLength,
@@ skipping 233 matching lines @@
     b = ((const uint8_t*)pGUID)[i];
     *pBuf++ = gs_FX_pHexChars[b >> 4];
     *pBuf++ = gs_FX_pHexChars[b & 0x0F];
     if (bSeparator && (i == 3 || i == 5 || i == 7 || i == 9)) {
       *pBuf++ = L'-';
     }
   }
   bsStr.ReleaseBuffer(bSeparator ? 36 : 32);
 }
 #endif  // PDF_ENABLE_XFA