Convert IFX_MemoryStream to CFX_MemoryStream

The CFX_MemoryStream is the only implementation of IFX_MemoryStream.
This CL removes the interfaces and uses CFX_MemoryStream directly.

Change-Id: I2f43fa39e82dafa7673517d214ae15fd2d0df331
Reviewed-on: https://pdfium-review.googlesource.com/4391
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: dsinclair <dsinclair@chromium.org>

1 files changed, 199 insertions, 0 deletions

diff --git a/core/fxcrt/cfx_memorystream.cpp b/core/fxcrt/cfx_memorystream.cpp
new file mode 100644
index 0000000000..345b381226
--- /dev/null
+++ b/core/fxcrt/cfx_memorystream.cpp
@@ -0,0 +1,199 @@
+// Copyright 2017 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/cfx_memorystream.h"
+
+#include <algorithm>
+
+#include "core/fxcrt/fx_safe_types.h"
+
+namespace {
+
+const int32_t kBlockSize = 64 * 1024;
+
+}  // namespace
+
+CFX_MemoryStream::CFX_MemoryStream(bool bConsecutive)
+    : m_nTotalSize(0),
+      m_nCurSize(0),
+      m_nCurPos(0),
+      m_nGrowSize(kBlockSize),
+      m_dwFlags(Type::kTakeOver | (bConsecutive ? Type::kConsecutive : 0)) {}
+
+CFX_MemoryStream::CFX_MemoryStream(uint8_t* pBuffer,
+                                   size_t nSize,
+                                   bool bTakeOver)
+    : m_nTotalSize(nSize),
+      m_nCurSize(nSize),
+      m_nCurPos(0),
+      m_nGrowSize(kBlockSize),
+      m_dwFlags(Type::kConsecutive | (bTakeOver ? Type::kTakeOver : 0)) {
+  m_Blocks.push_back(pBuffer);
+}
+
+CFX_MemoryStream::~CFX_MemoryStream() {
+  if (m_dwFlags & Type::kTakeOver) {
+    for (uint8_t* pBlock : m_Blocks)
+      FX_Free(pBlock);
+  }
+}
+
+FX_FILESIZE CFX_MemoryStream::GetSize() {
+  return static_cast<FX_FILESIZE>(m_nCurSize);
+}
+
+bool CFX_MemoryStream::IsEOF() {
+  return m_nCurPos >= static_cast<size_t>(GetSize());
+}
+
+FX_FILESIZE CFX_MemoryStream::GetPosition() {
+  return static_cast<FX_FILESIZE>(m_nCurPos);
+}
+
+bool CFX_MemoryStream::Flush() {
+  return true;
+}
+
+bool CFX_MemoryStream::ReadBlock(void* buffer,
+                                 FX_FILESIZE offset,
+                                 size_t size) {
+  if (!buffer || !size || offset < 0)
+    return false;
+
+  FX_SAFE_SIZE_T newPos = size;
+  newPos += offset;
+  if (!newPos.IsValid() || newPos.ValueOrDefault(0) == 0 ||
+      newPos.ValueOrDie() > m_nCurSize) {
+    return false;
+  }
+
+  m_nCurPos = newPos.ValueOrDie();
+  if (m_dwFlags & Type::kConsecutive) {
+    memcpy(buffer, m_Blocks[0] + static_cast<size_t>(offset), size);
+    return true;
+  }
+
+  size_t nStartBlock = static_cast<size_t>(offset) / m_nGrowSize;
+  offset -= static_cast<FX_FILESIZE>(nStartBlock * m_nGrowSize);
+  while (size) {
+    size_t nRead = std::min(size, m_nGrowSize - static_cast<size_t>(offset));
+    memcpy(buffer, m_Blocks[nStartBlock] + offset, nRead);
+    buffer = static_cast<uint8_t*>(buffer) + nRead;
+    size -= nRead;
+    ++nStartBlock;
+    offset = 0;
+  }
+  return true;
+}
+
+size_t CFX_MemoryStream::ReadBlock(void* buffer, size_t size) {
+  if (m_nCurPos >= m_nCurSize)
+    return 0;
+
+  size_t nRead = std::min(size, m_nCurSize - m_nCurPos);
+  if (!ReadBlock(buffer, static_cast<int32_t>(m_nCurPos), nRead))
+    return 0;
+
+  return nRead;
+}
+
+bool CFX_MemoryStream::WriteBlock(const void* buffer,
+                                  FX_FILESIZE offset,
+                                  size_t size) {
+  if (!buffer || !size)
+    return false;
+
+  if (m_dwFlags & Type::kConsecutive) {
+    FX_SAFE_SIZE_T newPos = size;
+    newPos += offset;
+    if (!newPos.IsValid())
+      return false;
+
+    m_nCurPos = newPos.ValueOrDie();
+    if (m_nCurPos > m_nTotalSize) {
+      m_nTotalSize = (m_nCurPos + m_nGrowSize - 1) / m_nGrowSize * m_nGrowSize;
+      if (m_Blocks.empty())
+        m_Blocks.push_back(FX_Alloc(uint8_t, m_nTotalSize));
+      else
+        m_Blocks[0] = FX_Realloc(uint8_t, m_Blocks[0], m_nTotalSize);
+    }
+
+    memcpy(m_Blocks[0] + offset, buffer, size);
+    m_nCurSize = std::max(m_nCurSize, m_nCurPos);
+
+    return true;
+  }
+
+  FX_SAFE_SIZE_T newPos = size;
+  newPos += offset;
+  if (!newPos.IsValid())
+    return false;
+  if (!ExpandBlocks(newPos.ValueOrDie()))
+    return false;
+
+  m_nCurPos = newPos.ValueOrDie();
+  size_t nStartBlock = static_cast<size_t>(offset) / m_nGrowSize;
+  offset -= static_cast<FX_FILESIZE>(nStartBlock * m_nGrowSize);
+  while (size) {
+    size_t nWrite = std::min(size, m_nGrowSize - static_cast<size_t>(offset));
+    memcpy(m_Blocks[nStartBlock] + offset, buffer, nWrite);
+    buffer = static_cast<const uint8_t*>(buffer) + nWrite;
+    size -= nWrite;
+    ++nStartBlock;
+    offset = 0;
+  }
+  return true;
+}
+
+void CFX_MemoryStream::EstimateSize(size_t nInitSize, size_t nGrowSize) {
+  if (m_dwFlags & Type::kConsecutive) {
+    if (m_Blocks.empty()) {
+      m_Blocks.push_back(
+          FX_Alloc(uint8_t, std::max(nInitSize, static_cast<size_t>(4096))));
+    }
+    m_nGrowSize = std::max(nGrowSize, static_cast<size_t>(4096));
+  } else if (m_Blocks.empty()) {
+    m_nGrowSize = std::max(nGrowSize, static_cast<size_t>(4096));
+  }
+}
+
+void CFX_MemoryStream::AttachBuffer(uint8_t* pBuffer, size_t nSize) {
+  if (!(m_dwFlags & Type::kConsecutive))
+    return;
+
+  m_Blocks.clear();
+  m_Blocks.push_back(pBuffer);
+  m_nTotalSize = nSize;
+  m_nCurSize = nSize;
+  m_nCurPos = 0;
+  m_dwFlags = Type::kConsecutive;
+}
+
+void CFX_MemoryStream::DetachBuffer() {
+  if (!(m_dwFlags & Type::kConsecutive))
+    return;
+
+  m_Blocks.clear();
+  m_nTotalSize = 0;
+  m_nCurSize = 0;
+  m_nCurPos = 0;
+  m_dwFlags = Type::kTakeOver;
+}
+
+bool CFX_MemoryStream::ExpandBlocks(size_t size) {
+  m_nCurSize = std::max(m_nCurSize, size);
+  if (size <= m_nTotalSize)
+    return true;
+
+  size = (size - m_nTotalSize + m_nGrowSize - 1) / m_nGrowSize;
+  size_t iCount = m_Blocks.size();
+  m_Blocks.resize(iCount + size);
+  while (size--) {
+    m_Blocks[iCount++] = FX_Alloc(uint8_t, m_nGrowSize);
+    m_nTotalSize += m_nGrowSize;
+  }
+  return true;
+}