Add CFDE_TxtEdtBuf tests

xfa/fde/cfde_txtedtbuf.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/fde/cfde_txtedtbuf.h"
 
 #include <algorithm>
 
@@ skipping 19 matching lines @@
 int32_t CFDE_TxtEdtBuf::GetChunkSize() const {
   return m_nChunkSize;
 }
 
 int32_t CFDE_TxtEdtBuf::GetTextLength() const {
   return m_nTotal;
 }
 
 void CFDE_TxtEdtBuf::SetText(const CFX_WideString& wsText) {
   ASSERT(!wsText.IsEmpty());
+
   Clear(false);
   int32_t nTextLength = wsText.GetLength();
   int32_t nNeedCount =
       ((nTextLength - 1) / m_nChunkSize + 1) - m_Chunks.GetSize();
   int32_t i = 0;
   for (i = 0; i < nNeedCount; i++) {
     FDE_CHUNKHEADER* lpChunk =
         static_cast<FDE_CHUNKHEADER*>(m_pAllocator->Alloc(
             sizeof(FDE_CHUNKHEADER) + (m_nChunkSize - 1) * sizeof(FX_WCHAR)));
     lpChunk->nUsed = 0;
@@ skipping 32 matching lines @@
     nTotal += pChunkHeader->nUsed;
     if (nTotal > nIndex) {
       break;
     }
   }
   ASSERT(pChunkHeader);
   return pChunkHeader->wChars[pChunkHeader->nUsed - (nTotal - nIndex)];
 }
 
 CFX_WideString CFDE_TxtEdtBuf::GetRange(int32_t nBegin, int32_t nLength) const {
+  if (nLength == 0 || GetTextLength() == 0)
+    return CFX_WideString();
+
+  ASSERT(nBegin >= 0 && nLength > 0 && nBegin < GetTextLength() &&
+         nBegin + nLength <= GetTextLength());

[Tom Sepez, 2017/01/09 21:07:27]

nit: this could overflow, but since its just an assert, meh.

[dsinclair, 2017/01/09 21:19:59]

Acknowledged.

+
   FDE_CHUNKPLACE cp;
   Index2CP(nBegin, cp);
   int32_t nLeave = nLength;
   int32_t nCount = m_Chunks.GetSize();
 
   CFX_WideString wsText;
   FX_WCHAR* lpDstBuf = wsText.GetBuffer(nLength);
   int32_t nChunkIndex = cp.nChunkIndex;
   FDE_CHUNKHEADER* lpChunkHeader = m_Chunks[nChunkIndex];
   int32_t nCopyLength = lpChunkHeader->nUsed - cp.nCharIndex;
@@ skipping 15 matching lines @@
   }
   wsText.ReleaseBuffer();
 
   return wsText;
 }
 
 void CFDE_TxtEdtBuf::Insert(int32_t nPos,
                             const FX_WCHAR* lpText,
                             int32_t nLength) {
   ASSERT(nPos >= 0 && nPos <= m_nTotal);
+  ASSERT(nLength > 0);
+
   FDE_CHUNKPLACE cp;
   Index2CP(nPos, cp);
   int32_t nLengthTemp = nLength;
   if (cp.nCharIndex != 0) {
     FDE_CHUNKHEADER* lpNewChunk =
         static_cast<FDE_CHUNKHEADER*>(m_pAllocator->Alloc(
             sizeof(FDE_CHUNKHEADER) + (m_nChunkSize - 1) * sizeof(FX_WCHAR)));
     FDE_CHUNKHEADER* lpChunk = m_Chunks[cp.nChunkIndex];
     int32_t nCopy = lpChunk->nUsed - cp.nCharIndex;
     FXSYS_memcpy(lpNewChunk->wChars, lpChunk->wChars + cp.nCharIndex,
@@ skipping 76 matching lines @@
     m_Chunks.RemoveAll();
   } else {
     while (i < nCount) {
       m_Chunks[i++]->nUsed = 0;
     }
   }
   m_nTotal = 0;
   m_bChanged = true;
 }
 
-bool CFDE_TxtEdtBuf::Optimize(IFX_Pause* pPause) {
-  if (m_bChanged == false) {
-    return true;
-  }
-  if (m_nTotal == 0) {
-    return true;
-  }
-  int32_t nCount = m_Chunks.GetSize();
-  if (nCount == 0) {
-    return true;
-  }
-  int32_t i = 0;
-  for (; i < nCount; i++) {
-    FDE_CHUNKHEADER* lpChunk = m_Chunks[i];
-    if (lpChunk->nUsed == 0) {
-      m_pAllocator->Free(lpChunk);
-      m_Chunks.RemoveAt(i);
-      --i;
-      --nCount;
-    }
-  }
-  if (pPause && pPause->NeedToPauseNow())
-    return false;
-
-  FDE_CHUNKHEADER* lpPreChunk = m_Chunks[0];
-  FDE_CHUNKHEADER* lpCurChunk = nullptr;
-  for (i = 1; i < nCount; i++) {
-    lpCurChunk = m_Chunks[i];
-    if (lpPreChunk->nUsed + lpCurChunk->nUsed <= m_nChunkSize) {
-      FXSYS_memcpy(lpPreChunk->wChars + lpPreChunk->nUsed, lpCurChunk->wChars,
-                   lpCurChunk->nUsed * sizeof(FX_WCHAR));
-      lpPreChunk->nUsed += lpCurChunk->nUsed;
-      m_pAllocator->Free(lpCurChunk);
-      m_Chunks.RemoveAt(i);
-      --i;
-      --nCount;
-    } else {
-      lpPreChunk = lpCurChunk;
-    }
-    if (pPause && pPause->NeedToPauseNow())
-      return false;
-  }
-  m_bChanged = false;
-  return true;
-}
-
 void CFDE_TxtEdtBuf::ResetChunkBuffer(int32_t nDefChunkCount,
                                       int32_t nChunkSize) {
   ASSERT(nChunkSize);
   ASSERT(nDefChunkCount);
   m_Chunks.RemoveAll();
   m_nChunkSize = nChunkSize;
   int32_t nChunkLength =
       sizeof(FDE_CHUNKHEADER) + (m_nChunkSize - 1) * sizeof(FX_WCHAR);
   m_pAllocator = IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Fixed, nDefChunkCount,
                                              nChunkLength);
   FDE_CHUNKHEADER* lpChunkHeader =
       static_cast<FDE_CHUNKHEADER*>(m_pAllocator->Alloc(nChunkLength));
   ASSERT(lpChunkHeader);
   lpChunkHeader->nUsed = 0;
   m_Chunks.Add(lpChunkHeader);
   m_nTotal = 0;
 }
 
+void CFDE_TxtEdtBuf::SetChunkSizeForTesting(size_t size) {
+  ResetChunkBuffer(kDefaultChunkCount, size);
+}
+
 int32_t CFDE_TxtEdtBuf::CP2Index(const FDE_CHUNKPLACE& cp) const {
   int32_t nTotal = cp.nCharIndex;
   int32_t i = 0;
   for (i = 0; i < cp.nChunkIndex; i++) {
     nTotal += m_Chunks[i]->nUsed;
   }
   return nTotal;
 }
 
 void CFDE_TxtEdtBuf::Index2CP(int32_t nIndex, FDE_CHUNKPLACE& cp) const {
   ASSERT(nIndex <= GetTextLength());
   if (nIndex == m_nTotal) {
     cp.nChunkIndex = m_Chunks.GetSize() - 1;
     cp.nCharIndex = m_Chunks[cp.nChunkIndex]->nUsed;
     return;
   }
   int32_t i = 0;
   int32_t nTotal = 0;
   int32_t nCount = m_Chunks.GetSize();
   for (; i < nCount; i++) {
     nTotal += m_Chunks[i]->nUsed;
     if (nTotal > nIndex) {
       break;
     }
   }
   cp.nChunkIndex = i;
   cp.nCharIndex = m_Chunks[i]->nUsed - (nTotal - nIndex);
 }