From f4bb580add3824196dc49cd7de2f7d051019ede8 Mon Sep 17 00:00:00 2001 From: weili Date: Tue, 14 Jun 2016 17:21:14 -0700 Subject: Make code compile with clang_use_chrome_plugin (part II) This change contains files in core directory which were not covered in part I. This is part of the efforts to make PDFium code compilable by Clang chromium style plugins. The changes are mainly the following: -- move inline constructor/destructor of complex class/struct out-of-line; -- add constructor/destructor of complex class/struct if not explicitly defined; -- add explicit out-of-line copy constructor when needed; -- move inline virtual functions out-of-line; -- Properly mark virtual functions with 'override'; -- some minor cleanups; BUG=pdfium:469 Review-Url: https://codereview.chromium.org/2060913003 --- core/fxcrt/fx_extension.cpp | 260 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 260 insertions(+) (limited to 'core/fxcrt/fx_extension.cpp') diff --git a/core/fxcrt/fx_extension.cpp b/core/fxcrt/fx_extension.cpp index 1a95e8c318..4c77244b3d 100644 --- a/core/fxcrt/fx_extension.cpp +++ b/core/fxcrt/fx_extension.cpp @@ -16,11 +16,271 @@ #include #endif +#ifdef PDF_ENABLE_XFA + +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() { + m_RefCount++; + return (IFX_FileAccess*)this; +} + +void CFX_CRTFileAccess::GetPath(CFX_WideString& wsPath) { + wsPath = m_path; +} + +IFX_FileStream* CFX_CRTFileAccess::CreateFileStream(uint32_t dwModes) { + return FX_CreateFileStream(m_path.c_str(), dwModes); +} + +FX_BOOL CFX_CRTFileAccess::Init(const CFX_WideStringC& wsPath) { + m_path = wsPath; + m_RefCount = 1; + return TRUE; +} + +#endif // PDF_ENABLE_XFA + CFX_CRTFileStream::CFX_CRTFileStream(std::unique_ptr pFA) : m_pFile(std::move(pFA)), m_dwCount(1) {} CFX_CRTFileStream::~CFX_CRTFileStream() {} +CFX_MemoryStream::CFX_MemoryStream(FX_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); +} + +CFX_MemoryStream::CFX_MemoryStream(uint8_t* pBuffer, + size_t nSize, + FX_BOOL bTakeOver) + : m_dwCount(1), + m_nTotalSize(nSize), + m_nCurSize(nSize), + m_nCurPos(0), + m_nGrowSize(FX_MEMSTREAM_BlockSize) { + m_Blocks.Add(pBuffer); + m_dwFlags = + FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOver : 0); +} + +CFX_MemoryStream::~CFX_MemoryStream() { + if (m_dwFlags & FX_MEMSTREAM_TakeOver) { + for (int32_t i = 0; i < m_Blocks.GetSize(); i++) { + FX_Free(m_Blocks[i]); + } + } + m_Blocks.RemoveAll(); +} + +IFX_FileStream* CFX_MemoryStream::Retain() { + m_dwCount++; + return this; +} + +void CFX_MemoryStream::Release() { + uint32_t nCount = --m_dwCount; + if (nCount) { + return; + } + delete this; +} + +FX_FILESIZE CFX_MemoryStream::GetSize() { + return (FX_FILESIZE)m_nCurSize; +} + +FX_BOOL CFX_MemoryStream::IsEOF() { + return m_nCurPos >= (size_t)GetSize(); +} + +FX_FILESIZE CFX_MemoryStream::GetPosition() { + return (FX_FILESIZE)m_nCurPos; +} + +FX_BOOL CFX_MemoryStream::ReadBlock(void* buffer, + FX_FILESIZE offset, + size_t size) { + if (!buffer || !size) { + 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 & FX_MEMSTREAM_Consecutive) { + FXSYS_memcpy(buffer, m_Blocks[0] + (size_t)offset, size); + return TRUE; + } + size_t nStartBlock = (size_t)offset / m_nGrowSize; + offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize); + while (size) { + size_t nRead = m_nGrowSize - (size_t)offset; + if (nRead > size) { + nRead = size; + } + FXSYS_memcpy(buffer, m_Blocks[(int)nStartBlock] + (size_t)offset, nRead); + buffer = ((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, (int32_t)m_nCurPos, nRead)) { + return 0; + } + return nRead; +} + +FX_BOOL CFX_MemoryStream::WriteBlock(const void* buffer, + FX_FILESIZE offset, + size_t size) { + if (!buffer || !size) { + return FALSE; + } + if (m_dwFlags & FX_MEMSTREAM_Consecutive) { + 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.GetSize() < 1) { + uint8_t* block = FX_Alloc(uint8_t, m_nTotalSize); + m_Blocks.Add(block); + } else { + m_Blocks[0] = FX_Realloc(uint8_t, m_Blocks[0], m_nTotalSize); + } + if (!m_Blocks[0]) { + m_Blocks.RemoveAll(); + return FALSE; + } + } + FXSYS_memcpy(m_Blocks[0] + (size_t)offset, buffer, size); + if (m_nCurSize < m_nCurPos) { + 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 = (size_t)offset / m_nGrowSize; + offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize); + while (size) { + size_t nWrite = m_nGrowSize - (size_t)offset; + if (nWrite > size) { + nWrite = size; + } + FXSYS_memcpy(m_Blocks[(int)nStartBlock] + (size_t)offset, buffer, nWrite); + buffer = ((uint8_t*)buffer) + nWrite; + size -= nWrite; + nStartBlock++; + offset = 0; + } + return TRUE; +} + +FX_BOOL CFX_MemoryStream::Flush() { + return TRUE; +} + +FX_BOOL CFX_MemoryStream::IsConsecutive() const { + return !!(m_dwFlags & FX_MEMSTREAM_Consecutive); +} + +void CFX_MemoryStream::EstimateSize(size_t nInitSize, size_t nGrowSize) { + if (m_dwFlags & FX_MEMSTREAM_Consecutive) { + if (m_Blocks.GetSize() < 1) { + uint8_t* pBlock = + FX_Alloc(uint8_t, std::max(nInitSize, static_cast(4096))); + m_Blocks.Add(pBlock); + } + m_nGrowSize = std::max(nGrowSize, static_cast(4096)); + } else if (m_Blocks.GetSize() < 1) { + m_nGrowSize = std::max(nGrowSize, static_cast(4096)); + } +} + +uint8_t* CFX_MemoryStream::GetBuffer() const { + return m_Blocks.GetSize() ? m_Blocks[0] : nullptr; +} + +void CFX_MemoryStream::AttachBuffer(uint8_t* pBuffer, + size_t nSize, + FX_BOOL bTakeOver) { + if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) { + return; + } + m_Blocks.RemoveAll(); + m_Blocks.Add(pBuffer); + m_nTotalSize = m_nCurSize = nSize; + m_nCurPos = 0; + m_dwFlags = + FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOver : 0); +} + +void CFX_MemoryStream::DetachBuffer() { + if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) { + return; + } + m_Blocks.RemoveAll(); + m_nTotalSize = m_nCurSize = m_nCurPos = 0; + m_dwFlags = FX_MEMSTREAM_TakeOver; +} + +FX_BOOL CFX_MemoryStream::ExpandBlocks(size_t size) { + if (m_nCurSize < size) { + m_nCurSize = size; + } + if (size <= m_nTotalSize) { + return TRUE; + } + int32_t iCount = m_Blocks.GetSize(); + 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_FileStream* CFX_CRTFileStream::Retain() { m_dwCount++; return this; -- cgit v1.2.3