Use smart pointers for class owned pointers

xfa/fgas/layout/fgas_textbreak.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/fgas/layout/fgas_textbreak.h"
 
 #include <algorithm>
 
@@ skipping 51 matching lines @@
       m_eCharType(FX_CHARTYPE_Unknown),
       m_bArabicNumber(FALSE),
       m_bArabicComma(FALSE),
       m_pCurLine(nullptr),
       m_iReady(0),
       m_iTolerance(0),
       m_iHorScale(100),
       m_iVerScale(100),
       m_iCharSpace(0) {
   m_bPagination = (m_dwPolicies & FX_TXTBREAKPOLICY_Pagination) != 0;
-  if (m_bPagination) {
-    m_pTxtLine1 = new CFX_TxtLine(sizeof(CFX_Char));
-    m_pTxtLine2 = new CFX_TxtLine(sizeof(CFX_Char));
-  } else {
-    m_pTxtLine1 = new CFX_TxtLine(sizeof(CFX_TxtChar));
-    m_pTxtLine2 = new CFX_TxtLine(sizeof(CFX_TxtChar));
-  }
-  m_pCurLine = m_pTxtLine1;
+  int32_t iSize = m_bPagination ? sizeof(CFX_Char) : sizeof(CFX_TxtChar);
+  m_pTxtLine1.reset(new CFX_TxtLine(iSize));
+  m_pTxtLine2.reset(new CFX_TxtLine(iSize));
+  m_pCurLine = m_pTxtLine1.get();
   ResetArabicContext();
 }
+
 CFX_TxtBreak::~CFX_TxtBreak() {
   Reset();
-  delete m_pTxtLine1;
-  delete m_pTxtLine2;
 }
+
 void CFX_TxtBreak::SetLineWidth(FX_FLOAT fLineWidth) {
   m_iLineWidth = FXSYS_round(fLineWidth * 20000.0f);
   ASSERT(m_iLineWidth >= 20000);
 }
+
 void CFX_TxtBreak::SetLinePos(FX_FLOAT fLinePos) {
   int32_t iLinePos = FXSYS_round(fLinePos * 20000.0f);
   if (iLinePos < 0) {
     iLinePos = 0;
   }
   if (iLinePos > m_iLineWidth) {
     iLinePos = m_iLineWidth;
   }
   m_pCurLine->m_iStart = iLinePos;
   m_pCurLine->m_iWidth += iLinePos;
 }
+
 void CFX_TxtBreak::SetLayoutStyles(uint32_t dwLayoutStyles) {
   m_dwLayoutStyles = dwLayoutStyles;
   m_bVertical = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_VerticalChars) != 0;
   m_bArabicContext = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_ArabicContext) != 0;
   m_bArabicShapes = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_ArabicShapes) != 0;
   m_bRTL = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_RTLReadingOrder) != 0;
   m_bSingleLine = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_SingleLine) != 0;
   m_bCombText = (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_CombText) != 0;
   ResetArabicContext();
   m_iLineRotation = GetLineRotation(m_dwLayoutStyles);
   m_iRotation = m_iLineRotation + m_iCharRotation;
   m_iRotation %= 4;
 }
+
 void CFX_TxtBreak::SetFont(CFGAS_GEFont* pFont) {
   if (!pFont) {
     return;
   }
   if (m_pFont == pFont) {
     return;
   }
   SetBreakStatus();
   m_pFont = pFont;
   m_iDefChar = 0;
   if (m_wDefChar != 0xFEFF && m_pFont) {
     m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
     m_iDefChar *= m_iFontSize;
   }
 }
+
 void CFX_TxtBreak::SetFontSize(FX_FLOAT fFontSize) {
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
   if (m_iFontSize == iFontSize) {
     return;
   }
   SetBreakStatus();
   m_iFontSize = iFontSize;
   m_iDefChar = 0;
   if (m_wDefChar != 0xFEFF && m_pFont) {
     m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
     m_iDefChar *= m_iFontSize;
   }
 }
+
 void CFX_TxtBreak::SetTabWidth(FX_FLOAT fTabWidth, FX_BOOL bEquidistant) {
   m_iTabWidth = FXSYS_round(fTabWidth * 20000.0f);
   if (m_iTabWidth < FX_TXTBREAK_MinimumTabWidth) {
     m_iTabWidth = FX_TXTBREAK_MinimumTabWidth;
   }
   m_bEquidistant = bEquidistant;
 }
+
 void CFX_TxtBreak::SetDefaultChar(FX_WCHAR wch) {
   m_wDefChar = wch;
   m_iDefChar = 0;
   if (m_wDefChar != 0xFEFF && m_pFont) {
     m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
     if (m_iDefChar < 0) {
       m_iDefChar = 0;
     } else {
       m_iDefChar *= m_iFontSize;
     }
   }
 }
+
 void CFX_TxtBreak::SetParagraphBreakChar(FX_WCHAR wch) {
   if (wch != L'\r' && wch != L'\n') {
     return;
   }
   m_wParagBreakChar = wch;
 }
+
 void CFX_TxtBreak::SetLineBreakTolerance(FX_FLOAT fTolerance) {
   m_iTolerance = FXSYS_round(fTolerance * 20000.0f);
 }
+
 void CFX_TxtBreak::SetCharRotation(int32_t iCharRotation) {
   if (iCharRotation < 0) {
     iCharRotation += (-iCharRotation / 4 + 1) * 4;
   } else if (iCharRotation > 3) {
     iCharRotation -= (iCharRotation / 4) * 4;
   }
   if (m_iCharRotation == iCharRotation) {
     return;
   }
   SetBreakStatus();
   m_iCharRotation = iCharRotation;
   m_iRotation = m_iLineRotation + m_iCharRotation;
   m_iRotation %= 4;
 }
+
 void CFX_TxtBreak::SetAlignment(int32_t iAlignment) {
   ASSERT(iAlignment >= FX_TXTLINEALIGNMENT_Left &&
          iAlignment <= FX_TXTLINEALIGNMENT_Distributed);
   m_iAlignment = iAlignment;
   ResetArabicContext();
 }
+
 void CFX_TxtBreak::ResetContextCharStyles() {
   m_dwContextCharStyles = m_bArabicContext ? m_iCurAlignment : m_iAlignment;
   if (m_bArabicNumber) {
     m_dwContextCharStyles |= FX_TXTCHARSTYLE_ArabicNumber;
   }
   if (m_bArabicComma) {
     m_dwContextCharStyles |= FX_TXTCHARSTYLE_ArabicComma;
   }
   if ((m_bArabicContext && m_bCurRTL) || (!m_bArabicContext && m_bRTL)) {
     m_dwContextCharStyles |= FX_TXTCHARSTYLE_RTLReadingOrder;
   }
   m_dwContextCharStyles |= (m_iArabicContext << 8);
 }
+
 uint32_t CFX_TxtBreak::GetContextCharStyles() const {
   return m_dwContextCharStyles;
 }
+
 void CFX_TxtBreak::SetContextCharStyles(uint32_t dwCharStyles) {
   m_iCurAlignment = dwCharStyles & 0x0F;
   m_bArabicNumber = (dwCharStyles & FX_TXTCHARSTYLE_ArabicNumber) != 0;
   m_bArabicComma = (dwCharStyles & FX_TXTCHARSTYLE_ArabicComma) != 0;
   m_bCurRTL = (dwCharStyles & FX_TXTCHARSTYLE_RTLReadingOrder) != 0;
   m_iCurArabicContext = m_iArabicContext = ((dwCharStyles & 0x0300) >> 8);
   ResetContextCharStyles();
 }
+
 void CFX_TxtBreak::SetCombWidth(FX_FLOAT fCombWidth) {
   m_iCombWidth = FXSYS_round(fCombWidth * 20000.0f);
 }
+
 void CFX_TxtBreak::SetUserData(void* pUserData) {
   if (m_pUserData == pUserData) {
     return;
   }
   SetBreakStatus();
   m_pUserData = pUserData;
 }
+
 void CFX_TxtBreak::SetBreakStatus() {
   if (m_bPagination) {
     return;
   }
   int32_t iCount = m_pCurLine->CountChars();
   if (iCount < 1) {
     return;
   }
   CFX_TxtChar* pTC = m_pCurLine->GetCharPtr(iCount - 1);
   if (pTC->m_dwStatus == 0) {
     pTC->m_dwStatus = FX_TXTBREAK_PieceBreak;
   }
 }
+
 void CFX_TxtBreak::SetHorizontalScale(int32_t iScale) {
   if (iScale < 0) {
     iScale = 0;
   }
   if (iScale == m_iHorScale) {
     return;
   }
   SetBreakStatus();
   m_iHorScale = iScale;
 }
+
 void CFX_TxtBreak::SetVerticalScale(int32_t iScale) {
   if (iScale < 0) {
     iScale = 0;
   }
   if (iScale == m_iHorScale) {
     return;
   }
   SetBreakStatus();
   m_iVerScale = iScale;
 }
+
 void CFX_TxtBreak::SetCharSpace(FX_FLOAT fCharSpace) {
   m_iCharSpace = FXSYS_round(fCharSpace * 20000.0f);
 }
+
 static const int32_t gs_FX_TxtLineRotations[8] = {0, 3, 1, 0, 2, 1, 3, 2};
 int32_t CFX_TxtBreak::GetLineRotation(uint32_t dwStyles) const {
   return gs_FX_TxtLineRotations[(dwStyles & 0x0E) >> 1];
 }
+
 CFX_TxtChar* CFX_TxtBreak::GetLastChar(int32_t index, FX_BOOL bOmitChar) const {
-  CFX_TxtCharArray& ca = *m_pCurLine->m_pLineChars;
+  CFX_TxtCharArray& ca = *m_pCurLine->m_pLineChars.get();
   int32_t iCount = ca.GetSize();
   if (index < 0 || index >= iCount) {
     return nullptr;
   }
   CFX_TxtChar* pTC;
   int32_t iStart = iCount - 1;
   while (iStart > -1) {
     pTC = ca.GetDataPtr(iStart--);
     if (bOmitChar && pTC->GetCharType() == FX_CHARTYPE_Combination) {
       continue;
     }
     if (--index < 0) {
       return pTC;
     }
   }
   return nullptr;
 }
+
 CFX_TxtLine* CFX_TxtBreak::GetTxtLine(FX_BOOL bReady) const {
   if (!bReady)
     return m_pCurLine;
   if (m_iReady == 1)
-    return m_pTxtLine1;
+    return m_pTxtLine1.get();
   if (m_iReady == 2)
-    return m_pTxtLine2;
+    return m_pTxtLine2.get();
   return nullptr;
 }
+
 CFX_TxtPieceArray* CFX_TxtBreak::GetTxtPieces(FX_BOOL bReady) const {
   CFX_TxtLine* pTxtLine = GetTxtLine(bReady);
   if (!pTxtLine) {
     return nullptr;
   }
-  return pTxtLine->m_pLinePieces;
+  return pTxtLine->m_pLinePieces.get();
 }
+
 inline FX_CHARTYPE CFX_TxtBreak::GetUnifiedCharType(
     FX_CHARTYPE chartype) const {
   return chartype >= FX_CHARTYPE_ArabicAlef ? FX_CHARTYPE_Arabic : chartype;
 }
+
 void CFX_TxtBreak::ResetArabicContext() {
   if (m_bArabicContext) {
     m_bCurRTL = m_iCurArabicContext > 1;
     m_iCurAlignment = m_iCurArabicContext > 1 ? FX_TXTLINEALIGNMENT_Right
                                               : FX_TXTLINEALIGNMENT_Left;
     m_iCurAlignment |= (m_iAlignment & FX_TXTLINEALIGNMENT_HigherMask);
     m_bArabicNumber = m_iArabicContext >= 1 && m_bArabicShapes;
   } else {
     if (m_bPagination) {
       m_bCurRTL = FALSE;
       m_iCurAlignment = 0;
     } else {
       m_bCurRTL = m_bRTL;
       m_iCurAlignment = m_iAlignment;
     }
     if (m_bRTL) {
       m_bArabicNumber = m_iArabicContext >= 1;
     } else {
       m_bArabicNumber = m_iArabicContext > 1;
     }
     m_bArabicNumber = m_bArabicNumber && m_bArabicShapes;
   }
   m_bArabicComma = m_bArabicNumber;
   ResetContextCharStyles();
 }
+
 void CFX_TxtBreak::AppendChar_PageLoad(CFX_TxtChar* pCurChar,
                                        uint32_t dwProps) {
   if (!m_bPagination) {
     pCurChar->m_dwStatus = 0;
     pCurChar->m_pUserData = m_pUserData;
   }
   if (m_bArabicContext || m_bArabicShapes) {
     int32_t iBidiCls = (dwProps & FX_BIDICLASSBITSMASK) >> FX_BIDICLASSBITS;
     int32_t iArabicContext =
         (iBidiCls == FX_BIDICLASS_R || iBidiCls == FX_BIDICLASS_AL)
             ? 2
             : ((iBidiCls == FX_BIDICLASS_L || iBidiCls == FX_BIDICLASS_S) ? 0
                                                                           : 1);
     if (iArabicContext != m_iArabicContext && iArabicContext != 1) {
       m_iArabicContext = iArabicContext;
       if (m_iCurArabicContext == 1) {
         m_iCurArabicContext = iArabicContext;
       }
       ResetArabicContext();
       if (!m_bPagination) {
         CFX_TxtChar* pLastChar = GetLastChar(1, FALSE);
         if (pLastChar && pLastChar->m_dwStatus < 1) {
           pLastChar->m_dwStatus = FX_TXTBREAK_PieceBreak;
         }
       }
     }
   }
   pCurChar->m_dwCharStyles = m_dwContextCharStyles;
 }
+
 uint32_t CFX_TxtBreak::AppendChar_Combination(CFX_TxtChar* pCurChar,
                                               int32_t iRotation) {
   FX_WCHAR wch = pCurChar->m_wCharCode;
   FX_WCHAR wForm;
   int32_t iCharWidth = 0;
   pCurChar->m_iCharWidth = -1;
   if (m_bCombText) {
     iCharWidth = m_iCombWidth;
   } else {
     if (m_bVertical != FX_IsOdd(iRotation)) {
@@ skipping 27 matching lines @@
       if (!m_pFont->GetCharWidth(wForm, iCharWidth, FALSE)) {
         iCharWidth = 0;
       }
     }
     iCharWidth *= m_iFontSize;
     iCharWidth = iCharWidth * m_iHorScale / 100;
   }
   pCurChar->m_iCharWidth = -iCharWidth;
   return FX_TXTBREAK_None;
 }
+
 uint32_t CFX_TxtBreak::AppendChar_Tab(CFX_TxtChar* pCurChar,
                                       int32_t iRotation) {
   m_eCharType = FX_CHARTYPE_Tab;
   if ((m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_ExpandTab) == 0) {
     return FX_TXTBREAK_None;
   }
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   int32_t iCharWidth;
   if (m_bCombText) {
     iCharWidth = m_iCombWidth;
   } else {
     if (m_bEquidistant) {
       iCharWidth = iLineWidth;
       iCharWidth = m_iTabWidth * (iCharWidth / m_iTabWidth + 1) - iCharWidth;
       if (iCharWidth < FX_TXTBREAK_MinimumTabWidth) {
         iCharWidth += m_iTabWidth;
       }
     } else {
       iCharWidth = m_iTabWidth;
     }
   }
   pCurChar->m_iCharWidth = iCharWidth;
   iLineWidth += iCharWidth;
   if (!m_bSingleLine && iLineWidth >= m_iLineWidth + m_iTolerance) {
     return EndBreak(FX_TXTBREAK_LineBreak);
   }
   return FX_TXTBREAK_None;
 }
+
 uint32_t CFX_TxtBreak::AppendChar_Control(CFX_TxtChar* pCurChar,
                                           int32_t iRotation) {
   m_eCharType = FX_CHARTYPE_Control;
   uint32_t dwRet = FX_TXTBREAK_None;
   if (!m_bSingleLine) {
     FX_WCHAR wch = pCurChar->m_wCharCode;
     switch (wch) {
       case L'\v':
       case 0x2028:
         dwRet = FX_TXTBREAK_LineBreak;
         break;
       case L'\f':
         dwRet = FX_TXTBREAK_PageBreak;
         break;
       case 0x2029:
         dwRet = FX_TXTBREAK_ParagraphBreak;
         break;
       default:
         if (wch == m_wParagBreakChar) {
           dwRet = FX_TXTBREAK_ParagraphBreak;
         }
         break;
     }
     if (dwRet != FX_TXTBREAK_None) {
       dwRet = EndBreak(dwRet);
     }
   }
   return dwRet;
 }
+
 uint32_t CFX_TxtBreak::AppendChar_Arabic(CFX_TxtChar* pCurChar,
                                          int32_t iRotation) {
   FX_CHARTYPE chartype = pCurChar->GetCharType();
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   FX_WCHAR wForm;
   int32_t iCharWidth = 0;
   CFX_Char* pLastChar = nullptr;
   FX_BOOL bAlef = FALSE;
   if (!m_bCombText && m_eCharType >= FX_CHARTYPE_ArabicAlef &&
       m_eCharType <= FX_CHARTYPE_ArabicDistortion) {
@@ skipping 44 matching lines @@
     iCharWidth = iCharWidth * m_iHorScale / 100;
   }
   pCurChar->m_iCharWidth = iCharWidth;
   iLineWidth += iCharWidth;
   m_pCurLine->m_iArabicChars++;
   if (!m_bSingleLine && iLineWidth > m_iLineWidth + m_iTolerance) {
     return EndBreak(FX_TXTBREAK_LineBreak);
   }
   return FX_TXTBREAK_None;
 }
+
 uint32_t CFX_TxtBreak::AppendChar_Others(CFX_TxtChar* pCurChar,
                                          int32_t iRotation) {
   uint32_t dwProps = pCurChar->m_dwCharProps;
   FX_CHARTYPE chartype = pCurChar->GetCharType();
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   int32_t iCharWidth = 0;
   m_eCharType = chartype;
   FX_WCHAR wch = pCurChar->m_wCharCode;
   FX_WCHAR wForm = wch;
   if (chartype == FX_CHARTYPE_Numeric) {
@@ skipping 65 matching lines @@
   }
   int32_t iRotation = m_iRotation;
   if (m_bVertical && (dwProps & 0x8000) != 0) {
     iRotation = (iRotation + 1) % 4;
   }
   uint32_t dwRet2 =
       (this->*g_FX_TxtBreak_lpfAppendChar[chartype >> FX_CHARTYPEBITS])(
           pCurChar, iRotation);
   return std::max(dwRet1, dwRet2);
 }
+
 void CFX_TxtBreak::EndBreak_UpdateArabicShapes() {
   ASSERT(m_bArabicShapes);
   int32_t iCount = m_pCurLine->CountChars();
   if (iCount < 2) {
     return;
   }
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   CFX_Char *pCur, *pNext;
   pCur = m_pCurLine->GetCharPtr(0);
   FX_BOOL bPrevNum = (pCur->m_dwCharStyles & FX_TXTCHARSTYLE_ArabicIndic) != 0;
@@ skipping 31 matching lines @@
           iCharWidth = iCharWidth * m_iHorScale / 100;
         }
         pCur->m_iCharWidth = iCharWidth;
         iLineWidth += iCharWidth;
       }
     }
     bPrevNum = (pCur->m_dwCharStyles & FX_TXTCHARSTYLE_ArabicIndic) != 0;
     pCur = pNext;
   } while (i < iCount);
 }
+
 FX_BOOL CFX_TxtBreak::EndBreak_SplitLine(CFX_TxtLine* pNextLine,
                                          FX_BOOL bAllChars,
                                          uint32_t dwStatus) {
   int32_t iCount = m_pCurLine->CountChars();
   FX_BOOL bDone = FALSE;
   CFX_Char* pTC;
   if (!m_bSingleLine && m_pCurLine->m_iWidth > m_iLineWidth + m_iTolerance) {
     pTC = m_pCurLine->GetCharPtr(iCount - 1);
     switch (pTC->GetCharType()) {
       case FX_CHARTYPE_Tab:
       case FX_CHARTYPE_Control:
         break;
       case FX_CHARTYPE_Space:
         if ((m_dwPolicies & FX_TXTBREAKPOLICY_SpaceBreak) != 0) {
           SplitTextLine(m_pCurLine, pNextLine, !m_bPagination && bAllChars);
           bDone = TRUE;
         }
         break;
       default:
         SplitTextLine(m_pCurLine, pNextLine, !m_bPagination && bAllChars);
         bDone = TRUE;
         break;
     }
   }
   iCount = m_pCurLine->CountChars();
-  CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces;
+  CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces.get();
   CFX_TxtPiece tp;
   if (m_bPagination) {
     tp.m_dwStatus = dwStatus;
     tp.m_iStartPos = m_pCurLine->m_iStart;
     tp.m_iWidth = m_pCurLine->m_iWidth;
     tp.m_iStartChar = 0;
     tp.m_iChars = iCount;
-    tp.m_pChars = m_pCurLine->m_pLineChars;
+    tp.m_pChars = m_pCurLine->m_pLineChars.get();
     tp.m_pUserData = m_pUserData;
     pTC = m_pCurLine->GetCharPtr(0);
     tp.m_dwCharStyles = pTC->m_dwCharStyles;
     tp.m_iHorizontalScale = pTC->m_iHorizontalScale;
     tp.m_iVerticalScale = pTC->m_iVertialScale;
     pCurPieces->Add(tp);
     m_pCurLine = pNextLine;
     m_eCharType = FX_CHARTYPE_Unknown;
     return TRUE;
   }
   if (bAllChars && !bDone) {
     int32_t iEndPos = m_pCurLine->m_iWidth;
-    GetBreakPos(*m_pCurLine->m_pLineChars, iEndPos, bAllChars, TRUE);
+    GetBreakPos(*m_pCurLine->m_pLineChars.get(), iEndPos, bAllChars, TRUE);
   }
   return FALSE;
 }
+
 void CFX_TxtBreak::EndBreak_BidiLine(CFX_TPOArray& tpos, uint32_t dwStatus) {
   CFX_TxtPiece tp;
   FX_TPO tpo;
   CFX_TxtChar* pTC;
   int32_t i, j;
-  CFX_TxtCharArray& chars = *m_pCurLine->m_pLineChars;
+  CFX_TxtCharArray& chars = *m_pCurLine->m_pLineChars.get();
   int32_t iCount = m_pCurLine->CountChars();
   FX_BOOL bDone = (m_pCurLine->m_iArabicChars > 0 || m_bCurRTL);
   if (!m_bPagination && bDone) {
     int32_t iBidiNum = 0;
     for (i = 0; i < iCount; i++) {
       pTC = chars.GetDataPtr(i);
       pTC->m_iBidiPos = i;
       if (pTC->GetCharType() != FX_CHARTYPE_Control) {
         iBidiNum = i;
       }
       if (i == 0) {
         pTC->m_iBidiLevel = 1;
       }
     }
     FX_BidiLine(chars, iBidiNum + 1, m_bCurRTL ? 1 : 0);
   }
-  CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces;
+  CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces.get();
   if (!m_bPagination &&
       (bDone || (m_dwLayoutStyles & FX_TXTLAYOUTSTYLE_MutipleFormat) != 0)) {
     tp.m_dwStatus = FX_TXTBREAK_PieceBreak;
     tp.m_iStartPos = m_pCurLine->m_iStart;
-    tp.m_pChars = m_pCurLine->m_pLineChars;
+    tp.m_pChars = m_pCurLine->m_pLineChars.get();
     int32_t iBidiLevel = -1, iCharWidth;
     i = 0, j = -1;
     while (i < iCount) {
       pTC = chars.GetDataPtr(i);
       if (iBidiLevel < 0) {
         iBidiLevel = pTC->m_iBidiLevel;
         tp.m_iWidth = 0;
         tp.m_iBidiLevel = iBidiLevel;
         tp.m_iBidiPos = pTC->m_iBidiOrder;
         tp.m_dwCharStyles = pTC->m_dwCharStyles;
@@ skipping 48 matching lines @@
       }
       CFX_TxtPiece& ttp = pCurPieces->GetAt(j);
       ttp.m_dwStatus = dwStatus;
     }
   } else {
     tp.m_dwStatus = dwStatus;
     tp.m_iStartPos = m_pCurLine->m_iStart;
     tp.m_iWidth = m_pCurLine->m_iWidth;
     tp.m_iStartChar = 0;
     tp.m_iChars = iCount;
-    tp.m_pChars = m_pCurLine->m_pLineChars;
+    tp.m_pChars = m_pCurLine->m_pLineChars.get();
     tp.m_pUserData = m_pUserData;
     pTC = chars.GetDataPtr(0);
     tp.m_dwCharStyles = pTC->m_dwCharStyles;
     tp.m_iHorizontalScale = pTC->m_iHorizontalScale;
     tp.m_iVerticalScale = pTC->m_iVertialScale;
     pCurPieces->Add(tp);
     tpo.index = 0;
     tpo.pos = 0;
     tpos.Add(tpo);
   }
 }
+
 void CFX_TxtBreak::EndBreak_Alignment(CFX_TPOArray& tpos,
                                       FX_BOOL bAllChars,
                                       uint32_t dwStatus) {
   int32_t iNetWidth = m_pCurLine->m_iWidth, iGapChars = 0, iCharWidth;
-  CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces;
+  CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces.get();
   int32_t i, j, iCount = pCurPieces->GetSize();
   FX_BOOL bFind = FALSE;
   FX_TPO tpo;
   CFX_TxtChar* pTC;
   FX_CHARTYPE chartype;
   for (i = iCount - 1; i > -1; i--) {
     tpo = tpos.GetAt(i);
     CFX_TxtPiece& ttp = pCurPieces->GetAt(tpo.index);
     if (!bFind) {
       iNetWidth = ttp.GetEndPos();
@@ skipping 64 matching lines @@
       iOffset /= 2;
     }
     if (iOffset > 0) {
       for (i = 0; i < iCount; i++) {
         CFX_TxtPiece& ttp = pCurPieces->GetAt(i);
         ttp.m_iStartPos += iOffset;
       }
     }
   }
 }
+
 uint32_t CFX_TxtBreak::EndBreak(uint32_t dwStatus) {
   ASSERT(dwStatus >= FX_TXTBREAK_PieceBreak &&
          dwStatus <= FX_TXTBREAK_PageBreak);
-  CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces;
+  CFX_TxtPieceArray* pCurPieces = m_pCurLine->m_pLinePieces.get();
   int32_t iCount = pCurPieces->GetSize();
   if (iCount > 0) {
     CFX_TxtPiece* pLastPiece = pCurPieces->GetPtrAt(--iCount);
     if (dwStatus > FX_TXTBREAK_PieceBreak) {
       pLastPiece->m_dwStatus = dwStatus;
     } else {
       dwStatus = pLastPiece->m_dwStatus;
     }
     return dwStatus;
   } else {
     CFX_TxtLine* pLastLine = GetTxtLine(TRUE);
     if (pLastLine) {
-      pCurPieces = pLastLine->m_pLinePieces;
+      pCurPieces = pLastLine->m_pLinePieces.get();
       iCount = pCurPieces->GetSize();
       if (iCount-- > 0) {
         CFX_TxtPiece* pLastPiece = pCurPieces->GetPtrAt(iCount);
         if (dwStatus > FX_TXTBREAK_PieceBreak) {
           pLastPiece->m_dwStatus = dwStatus;
         } else {
           dwStatus = pLastPiece->m_dwStatus;
         }
         return dwStatus;
       }
       return FX_TXTBREAK_None;
     }
     iCount = m_pCurLine->CountChars();
     if (iCount < 1) {
       return FX_TXTBREAK_None;
     }
     if (!m_bPagination) {
       CFX_TxtChar* pTC = m_pCurLine->GetCharPtr(iCount - 1);
       pTC->m_dwStatus = dwStatus;
     }
     if (dwStatus <= FX_TXTBREAK_PieceBreak) {
       return dwStatus;
     }
   }
-  m_iReady = (m_pCurLine == m_pTxtLine1) ? 1 : 2;
+  m_iReady = (m_pCurLine == m_pTxtLine1.get()) ? 1 : 2;
   CFX_TxtLine* pNextLine =
-      (m_pCurLine == m_pTxtLine1) ? m_pTxtLine2 : m_pTxtLine1;
+      (m_pCurLine == m_pTxtLine1.get()) ? m_pTxtLine2.get() : m_pTxtLine1.get();
   FX_BOOL bAllChars = (m_iCurAlignment > FX_TXTLINEALIGNMENT_Right);
   CFX_TPOArray tpos(100);
   CFX_Char* pTC;
   if (m_bArabicShapes) {
     EndBreak_UpdateArabicShapes();
   }
   if (EndBreak_SplitLine(pNextLine, bAllChars, dwStatus)) {
     goto EndBreak_Ret;
   }
   EndBreak_BidiLine(tpos, dwStatus);
   if (!m_bPagination && m_iCurAlignment > FX_TXTLINEALIGNMENT_Left) {
     EndBreak_Alignment(tpos, bAllChars, dwStatus);
   }
 EndBreak_Ret:
   m_pCurLine = pNextLine;
   pTC = GetLastChar(0, FALSE);
   m_eCharType = pTC ? pTC->GetCharType() : FX_CHARTYPE_Unknown;
   if (dwStatus == FX_TXTBREAK_ParagraphBreak) {
     m_iArabicContext = m_iCurArabicContext = 1;
     ResetArabicContext();
   }
   return dwStatus;
 }
+
 int32_t CFX_TxtBreak::GetBreakPos(CFX_TxtCharArray& ca,
                                   int32_t& iEndPos,
                                   FX_BOOL bAllChars,
                                   FX_BOOL bOnlyBrk) {
   int32_t iLength = ca.GetSize() - 1;
   if (iLength < 1) {
     return iLength;
   }
   int32_t iBreak = -1, iBreakPos = -1, iIndirect = -1, iIndirectPos = -1,
           iLast = -1, iLastPos = -1;
@@ skipping 76 matching lines @@
   if (iIndirect > -1) {
     iEndPos = iIndirectPos;
     return iIndirect;
   }
   if (iLast > -1) {
     iEndPos = iLastPos;
     return iLast;
   }
   return 0;
 }
+
 void CFX_TxtBreak::SplitTextLine(CFX_TxtLine* pCurLine,
                                  CFX_TxtLine* pNextLine,
                                  FX_BOOL bAllChars) {
   ASSERT(pCurLine && pNextLine);
   int32_t iCount = pCurLine->CountChars();
   if (iCount < 2) {
     return;
   }
   int32_t iEndPos = pCurLine->m_iWidth;
-  CFX_TxtCharArray& curChars = *pCurLine->m_pLineChars;
+  CFX_TxtCharArray& curChars = *pCurLine->m_pLineChars.get();
   int32_t iCharPos = GetBreakPos(curChars, iEndPos, bAllChars, FALSE);
   if (iCharPos < 0) {
     iCharPos = 0;
   }
   iCharPos++;
   if (iCharPos >= iCount) {
     pNextLine->RemoveAll(TRUE);
     CFX_Char* pTC = curChars.GetDataPtr(iCharPos - 1);
     pTC->m_nBreakType = FX_LBT_UNKNOWN;
     return;
   }
-  CFX_TxtCharArray& nextChars = *pNextLine->m_pLineChars;
+  CFX_TxtCharArray& nextChars = *pNextLine->m_pLineChars.get();
   int cur_size = curChars.GetSize();
   nextChars.SetSize(cur_size - iCharPos);
   FXSYS_memcpy(nextChars.GetData(), curChars.GetDataPtr(iCharPos),
                (cur_size - iCharPos) * sizeof(CFX_TxtChar));
   iCount -= iCharPos;
   cur_size = curChars.GetSize();
   curChars.RemoveAt(cur_size - iCount, iCount);
   pCurLine->m_iWidth = iEndPos;
   CFX_TxtChar* pTC = curChars.GetDataPtr(iCharPos - 1);
   pTC->m_nBreakType = FX_LBT_UNKNOWN;
   iCount = nextChars.GetSize();
   int32_t iCharWidth, iWidth = 0;
   for (int32_t i = 0; i < iCount; i++) {
     pTC = nextChars.GetDataPtr(i);
     if (pTC->GetCharType() >= FX_CHARTYPE_ArabicAlef) {
       pCurLine->m_iArabicChars--;
       pNextLine->m_iArabicChars++;
     }
     iCharWidth = pTC->m_iCharWidth;
     if (iCharWidth > 0) {
       iWidth += iCharWidth;
     }
     if (m_bPagination) {
       continue;
     }
     pTC->m_dwStatus = 0;
   }
   pNextLine->m_iWidth = iWidth;
 }
+
 int32_t CFX_TxtBreak::CountBreakChars() const {
   CFX_TxtLine* pTxtLine = GetTxtLine(TRUE);
   return pTxtLine ? pTxtLine->CountChars() : 0;
 }
+
 int32_t CFX_TxtBreak::CountBreakPieces() const {
   CFX_TxtPieceArray* pTxtPieces = GetTxtPieces(TRUE);
   return pTxtPieces ? pTxtPieces->GetSize() : 0;
 }
+
 const CFX_TxtPiece* CFX_TxtBreak::GetBreakPiece(int32_t index) const {
   CFX_TxtPieceArray* pTxtPieces = GetTxtPieces(TRUE);
   if (!pTxtPieces) {
     return nullptr;
   }
   if (index < 0 || index >= pTxtPieces->GetSize()) {
     return nullptr;
   }
   return pTxtPieces->GetPtrAt(index);
 }
+
 void CFX_TxtBreak::ClearBreakPieces() {
   CFX_TxtLine* pTxtLine = GetTxtLine(TRUE);
   if (pTxtLine) {
     pTxtLine->RemoveAll(TRUE);
   }
   m_iReady = 0;
 }
+
 void CFX_TxtBreak::Reset() {
   m_eCharType = FX_CHARTYPE_Unknown;
   m_iArabicContext = m_iCurArabicContext = 1;
   ResetArabicContext();
   m_pTxtLine1->RemoveAll(TRUE);
   m_pTxtLine2->RemoveAll(TRUE);
 }
 
 struct FX_FORMCHAR {
   uint16_t wch;
@@ skipping 383 matching lines @@
         pCharPos++;
       }
     }
     if (iWidth > 0) {
       wPrev = (FX_WCHAR)formChars[0].wch;
     }
     wLast = wch;
   }
   return iCount;
 }
+
 int32_t CFX_TxtBreak::GetCharRects(const FX_TXTRUN* pTxtRun,
                                    CFX_RectFArray& rtArray,
                                    FX_BOOL bCharBBox) const {
   if (!pTxtRun || pTxtRun->iLength < 1) {
     return 0;
   }
   IFX_TxtAccess* pAccess = pTxtRun->pAccess;
   const FDE_TEXTEDITPIECE* pIdentity = pTxtRun->pIdentity;
   const FX_WCHAR* pStr = pTxtRun->wsStr.c_str();
   int32_t* pWidths = pTxtRun->pWidths;
@@ skipping 127 matching lines @@
       m_iChars(0),
       m_iBidiLevel(0),
       m_iBidiPos(0),
       m_iHorizontalScale(100),
       m_iVerticalScale(100),
       m_dwCharStyles(0),
       m_pChars(nullptr),
       m_pUserData(nullptr) {}
 
 CFX_TxtLine::CFX_TxtLine(int32_t iBlockSize)
-    : m_iStart(0), m_iWidth(0), m_iArabicChars(0) {
-  m_pLineChars = new CFX_TxtCharArray;
-  m_pLinePieces = new CFX_TxtPieceArray(16);
-}
+    : m_pLineChars(new CFX_TxtCharArray),
+      m_pLinePieces(new CFX_TxtPieceArray(16)),
+      m_iStart(0),
+      m_iWidth(0),
+      m_iArabicChars(0) {}
 
 CFX_TxtLine::~CFX_TxtLine() {
   RemoveAll();
-  delete m_pLineChars;
-  delete m_pLinePieces;
 }