Make more concrete stream classes private to .cpp files

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>
 #include <utility>
 
 #include "core/fxcrt/fx_basic.h"
 #include "core/fxcrt/fx_ext.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 #include <wincrypt.h>
 #else
 #include <ctime>
 #endif
 
+namespace {
+
 #ifdef PDF_ENABLE_XFA
 
+class CFX_CRTFileAccess : public IFX_FileAccess {
+ public:
+  CFX_CRTFileAccess();
+  ~CFX_CRTFileAccess() override;
+
+  // IFX_FileAccess
+  void Release() override;
+  IFX_FileAccess* Retain() override;
+  void GetPath(CFX_WideString& wsPath) override;
+  IFX_SeekableStream* CreateFileStream(uint32_t dwModes) override;
+
+  bool Init(const CFX_WideStringC& wsPath);
+
+ private:
+  CFX_WideString m_path;
+  uint32_t m_RefCount;
+};
+
 CFX_CRTFileAccess::CFX_CRTFileAccess() : m_RefCount(0) {}
 
 CFX_CRTFileAccess::~CFX_CRTFileAccess() {}
 
 void CFX_CRTFileAccess::Release() {
   if (--m_RefCount == 0)
     delete this;
 }
 
 IFX_FileAccess* CFX_CRTFileAccess::Retain() {
@@ skipping 10 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;
+
+  // IFX_SeekableStream:
+  IFX_SeekableStream* Retain() override;
+  void Release() override;
+  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:
+  std::unique_ptr<IFXCRT_FileAccess> m_pFile;
+  uint32_t m_dwCount;
+};
+
 CFX_CRTFileStream::CFX_CRTFileStream(std::unique_ptr<IFXCRT_FileAccess> pFA)
     : m_pFile(std::move(pFA)), m_dwCount(1) {}
 
 CFX_CRTFileStream::~CFX_CRTFileStream() {}
+IFX_SeekableStream* CFX_CRTFileStream::Retain() {
+  m_dwCount++;
+  return this;
+}
+
+void CFX_CRTFileStream::Release() {
+  uint32_t nCount = --m_dwCount;
+  if (!nCount)
+    delete this;
+}
+
+FX_FILESIZE CFX_CRTFileStream::GetSize() {
+  return m_pFile->GetSize();
+}
+
+bool CFX_CRTFileStream::IsEOF() {
+  return GetPosition() >= GetSize();
+}
+
+FX_FILESIZE CFX_CRTFileStream::GetPosition() {
+  return m_pFile->GetPosition();
+}
+
+bool CFX_CRTFileStream::ReadBlock(void* buffer,
+                                  FX_FILESIZE offset,
+                                  size_t size) {
+  return m_pFile->ReadPos(buffer, size, offset) > 0;
+}
+
+size_t CFX_CRTFileStream::ReadBlock(void* buffer, size_t size) {
+  return m_pFile->Read(buffer, size);
+}
+
+bool CFX_CRTFileStream::WriteBlock(const void* buffer,
+                                   FX_FILESIZE offset,
+                                   size_t size) {
+  return !!m_pFile->WritePos(buffer, size, offset);
+}
+
+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;
+
+  // IFX_MemoryStream
+  IFX_SeekableStream* Retain() override;
+  void Release() override;
+  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:
+  CFX_ArrayTemplate<uint8_t*> m_Blocks;
+  uint32_t m_dwCount;
+  size_t m_nTotalSize;
+  size_t m_nCurSize;
+  size_t m_nCurPos;
+  size_t m_nGrowSize;
+  uint32_t m_dwFlags;
+  bool ExpandBlocks(size_t size);
+};
 
 CFX_MemoryStream::CFX_MemoryStream(bool bConsecutive)
     : m_dwCount(1),
       m_nTotalSize(0),
       m_nCurSize(0),
       m_nCurPos(0),
       m_nGrowSize(FX_MEMSTREAM_BlockSize) {
   m_dwFlags =
       FX_MEMSTREAM_TakeOver | (bConsecutive ? FX_MEMSTREAM_Consecutive : 0);
 }
@@ skipping 208 matching lines @@
   size = (size - m_nTotalSize + m_nGrowSize - 1) / m_nGrowSize;
   m_Blocks.SetSize(m_Blocks.GetSize() + (int32_t)size);
   while (size--) {
     uint8_t* pBlock = FX_Alloc(uint8_t, m_nGrowSize);
     m_Blocks.SetAt(iCount++, pBlock);
     m_nTotalSize += m_nGrowSize;
   }
   return true;
 }
 
-IFX_SeekableStream* CFX_CRTFileStream::Retain() {
-  m_dwCount++;
-  return this;
-}
-
-void CFX_CRTFileStream::Release() {
-  uint32_t nCount = --m_dwCount;
-  if (!nCount) {
-    delete this;
-  }
-}
-
-FX_FILESIZE CFX_CRTFileStream::GetSize() {
-  return m_pFile->GetSize();
-}
-
-bool CFX_CRTFileStream::IsEOF() {
-  return GetPosition() >= GetSize();
-}
-
-FX_FILESIZE CFX_CRTFileStream::GetPosition() {
-  return m_pFile->GetPosition();
-}
-
-bool CFX_CRTFileStream::ReadBlock(void* buffer,
-                                  FX_FILESIZE offset,
-                                  size_t size) {
-  return m_pFile->ReadPos(buffer, size, offset) > 0;
-}
-
-size_t CFX_CRTFileStream::ReadBlock(void* buffer, size_t size) {
-  return m_pFile->Read(buffer, size);
-}
-
-bool CFX_CRTFileStream::WriteBlock(const void* buffer,
-                                   FX_FILESIZE offset,
-                                   size_t size) {
-  return !!m_pFile->WritePos(buffer, size, offset);
-}
-
-bool CFX_CRTFileStream::Flush() {
-  return m_pFile->Flush();
-}
+}  // namespace
 
 #ifdef PDF_ENABLE_XFA
 IFX_FileAccess* FX_CreateDefaultFileAccess(const CFX_WideStringC& wsPath) {
   if (wsPath.GetLength() == 0)
     return nullptr;
 
   CFX_CRTFileAccess* pFA = new CFX_CRTFileAccess;
   pFA->Init(wsPath);
   return pFA;
 }
@@ skipping 281 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