Use smart pointers for class owned pointers under xfa/fde

xfa/fde/cfde_txtedtpage.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_txtedtpage.h"
 
 #include <algorithm>
 
@@ skipping 11 matching lines @@
 const double kTolerance = 0.1f;
 
 }  // namespace
 
 IFDE_TxtEdtPage* IFDE_TxtEdtPage::Create(CFDE_TxtEdtEngine* pEngine,
                                          int32_t nIndex) {
   return new CFDE_TxtEdtPage(pEngine, nIndex);
 }
 
 CFDE_TxtEdtPage::CFDE_TxtEdtPage(CFDE_TxtEdtEngine* pEngine, int32_t nPageIndex)
-    : m_pTextSet(nullptr),
+    : m_pEditEngine(pEngine),
       m_PieceMassArr(100),
       m_pBgnParag(nullptr),
       m_pEndParag(nullptr),
       m_nRefCount(0),
       m_nPageStart(-1),
       m_nCharCount(0),
       m_nPageIndex(nPageIndex),
-      m_bLoaded(FALSE),
-      m_pCharWidth(nullptr) {
+      m_bLoaded(FALSE) {
   FXSYS_memset(&m_rtPage, 0, sizeof(CFX_RectF));
   FXSYS_memset(&m_rtPageMargin, 0, sizeof(CFX_RectF));
   FXSYS_memset(&m_rtPageContents, 0, sizeof(CFX_RectF));
   FXSYS_memset(&m_rtPageCanvas, 0, sizeof(CFX_RectF));
-  m_pEditEngine = static_cast<CFDE_TxtEdtEngine*>(pEngine);
 }
 
 CFDE_TxtEdtPage::~CFDE_TxtEdtPage() {
   m_PieceMassArr.RemoveAll(TRUE);
-  delete m_pTextSet;
-  delete[] m_pCharWidth;
 }
 
 CFDE_TxtEdtEngine* CFDE_TxtEdtPage::GetEngine() const {
   return m_pEditEngine;
 }
 
 FDE_VISUALOBJTYPE CFDE_TxtEdtPage::GetType() {
   return FDE_VISUALOBJ_Text;
 }
 
@@ skipping 238 matching lines @@
   FX_BOOL bLineReserve =
       pParams->dwLayoutStyles & FDE_TEXTEDITLAYOUT_LineReserve;
   FX_FLOAT fLineStart =
       bVertial
           ? (bLineReserve ? (pParams->fPlateWidth - pParams->fLineSpace) : 0.0f)
           : 0.0f;
   FX_FLOAT fLineStep =
       (bVertial && bLineReserve) ? (-pParams->fLineSpace) : pParams->fLineSpace;
   FX_FLOAT fLinePos = fLineStart;
   if (!m_pTextSet)
-    m_pTextSet = new CFDE_TxtEdtTextSet(this);
+    m_pTextSet.reset(new CFDE_TxtEdtTextSet(this));
 
   m_PieceMassArr.RemoveAll(TRUE);
   uint32_t dwBreakStatus = FX_TXTBREAK_None;
   int32_t nPieceStart = 0;
-  delete[] m_pCharWidth;
 
-  m_pCharWidth = new int32_t[nPageEnd - nPageStart + 1];
+  m_CharWidths.resize(nPageEnd - nPageStart + 1, 0);
   pBreak->EndBreak(FX_TXTBREAK_ParagraphBreak);
   pBreak->ClearBreakPieces();
   m_nPageStart = nPageStart;
   m_nCharCount = nPageEnd - nPageStart + 1;
   FX_BOOL bReload = FALSE;
   FX_FLOAT fDefCharWidth = 0;
   std::unique_ptr<IFX_CharIter> pIter(m_pIter->Clone());
   pIter->SetAt(nPageStart);
   m_pIter->SetAt(nPageStart);
   FX_BOOL bFirstPiece = TRUE;
@@ skipping 58 matching lines @@
         if (bFirstPiece) {
           m_rtPageContents = TxtEdtPiece.rtPiece;
           bFirstPiece = FALSE;
         } else {
           m_rtPageContents.Union(TxtEdtPiece.rtPiece);
         }
         nPieceStart += TxtEdtPiece.nCount;
         m_PieceMassArr.Add(TxtEdtPiece);
         for (int32_t k = 0; k < TxtEdtPiece.nCount; k++) {
           CFX_Char* ptc = pPiece->GetCharPtr(k);
-          m_pCharWidth[TxtEdtPiece.nStart + k] = ptc->m_iCharWidth;
+          m_CharWidths[TxtEdtPiece.nStart + k] = ptc->m_iCharWidth;
         }
       }
       fLinePos += fLineStep;
       pBreak->ClearBreakPieces();
     }
     if (pIter->GetAt() == nPageEnd && dwBreakStatus == FX_TXTBREAK_LineBreak) {
       bReload = TRUE;
       pIter->Next(TRUE);
     }
   } while (pIter->Next(FALSE) && (pIter->GetAt() <= nPageEnd));
@@ skipping 33 matching lines @@
   return 0;
 }
 
 void CFDE_TxtEdtPage::UnloadPage(const CFX_RectF* pClipBox) {
   ASSERT(m_nRefCount > 0);
   m_nRefCount--;
   if (m_nRefCount != 0)
     return;
 
   m_PieceMassArr.RemoveAll(FALSE);
-  delete m_pTextSet;
-  m_pTextSet = nullptr;
-  delete[] m_pCharWidth;
-  m_pCharWidth = nullptr;
+  m_pTextSet.reset();
+  m_CharWidths.clear();
   if (m_pBgnParag) {
     m_pBgnParag->UnloadParag();
     m_pBgnParag = nullptr;
   }
   if (m_pEndParag) {
     m_pEndParag->UnloadParag();
     m_pEndParag = nullptr;
   }
   m_pIter.reset();
 }
 
 const CFX_RectF& CFDE_TxtEdtPage::GetContentsBox() {
   return m_rtPageContents;
 }
 
 FX_POSITION CFDE_TxtEdtPage::GetFirstPosition() {
   if (m_PieceMassArr.GetSize() < 1)
     return nullptr;
   return (FX_POSITION)1;
 }
 
 FDE_TEXTEDITPIECE* CFDE_TxtEdtPage::GetNext(FX_POSITION& pos,
                                             IFDE_VisualSet*& pVisualSet) {
   if (!m_pTextSet) {
     pos = nullptr;
     return nullptr;
   }
   int32_t nPos = (int32_t)(uintptr_t)pos;
-  pVisualSet = m_pTextSet;
+  pVisualSet = m_pTextSet.get();
   if (nPos + 1 > m_PieceMassArr.GetSize()) {
     pos = nullptr;
   } else {
     pos = (FX_POSITION)(uintptr_t)(nPos + 1);
   }
   return m_PieceMassArr.GetPtrAt(nPos - 1);
 }
 
 FX_WCHAR CFDE_TxtEdtPage::GetChar(const FDE_TEXTEDITPIECE* pIdentity,
                                   int32_t index) const {
   int32_t nIndex = m_nPageStart + pIdentity->nStart + index;
   if (nIndex != m_pIter->GetAt()) {
     m_pIter->SetAt(nIndex);
   }
   FX_WCHAR wChar = m_pIter->GetChar();
   m_pIter->Next();
   return wChar;
 }
 
 int32_t CFDE_TxtEdtPage::GetWidth(const FDE_TEXTEDITPIECE* pIdentity,
                                   int32_t index) const {
-  int32_t nWidth = m_pCharWidth[pIdentity->nStart + index];
+  int32_t nWidth = m_CharWidths[pIdentity->nStart + index];
   return nWidth;
 }
 
 void CFDE_TxtEdtPage::NormalizePt2Rect(CFX_PointF& ptF,
                                        const CFX_RectF& rtF,
                                        FX_FLOAT fTolerance) const {
   if (rtF.Contains(ptF.x, ptF.y)) {
     return;
   }
   if (ptF.x < rtF.left) {
     ptF.x = rtF.left;
   } else if (ptF.x >= rtF.right()) {
     ptF.x = rtF.right() - fTolerance;
   }
   if (ptF.y < rtF.top) {
     ptF.y = rtF.top;
   } else if (ptF.y >= rtF.bottom()) {
     ptF.y = rtF.bottom() - fTolerance;
   }
 }