Remove Release() from CFX_RTFBreak

xfa/fxfa/app/xfa_textlayout.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/fxfa/app/xfa_textlayout.h"
 
 #include <algorithm>
 
@@ skipping 15 matching lines @@
                                      int32_t iDeclCount) {
   if (iDeclCount <= 0 || !ppDeclArray)
     return;
 
   m_dwMatchedDecls = iDeclCount;
   m_ppMatchedDecls = FX_Alloc(CFDE_CSSDeclaration*, iDeclCount);
   FXSYS_memcpy(m_ppMatchedDecls, ppDeclArray,
                iDeclCount * sizeof(CFDE_CSSDeclaration*));
 }
 
-CXFA_TextParser::CXFA_TextParser() : m_pAllocator(NULL), m_pUASheet(NULL) {}
+CXFA_TextParser::CXFA_TextParser() : m_pUASheet(nullptr) {}
 
 CXFA_TextParser::~CXFA_TextParser() {
   if (m_pUASheet)
     m_pUASheet->Release();
 
-  delete m_pAllocator;
   FX_POSITION ps = m_mapXMLNodeToParseContext.GetStartPosition();
   while (ps) {
     CFDE_XMLNode* pXMLNode;
     CXFA_TextParseContext* pParseContext;
     m_mapXMLNodeToParseContext.GetNextAssoc(ps, pXMLNode, pParseContext);
     if (pParseContext)
-      FXTARGET_DeleteWith(CXFA_TextParseContext, m_pAllocator, pParseContext);
+      FXTARGET_DeleteWith(CXFA_TextParseContext, m_pAllocator.get(),
+                          pParseContext);
   }
   m_mapXMLNodeToParseContext.RemoveAll();
 }
 void CXFA_TextParser::Reset() {
   FX_POSITION ps = m_mapXMLNodeToParseContext.GetStartPosition();
   while (ps) {
     CFDE_XMLNode* pXMLNode;
     CXFA_TextParseContext* pParseContext;
     m_mapXMLNodeToParseContext.GetNextAssoc(ps, pXMLNode, pParseContext);
     if (pParseContext)
-      FXTARGET_DeleteWith(CXFA_TextParseContext, m_pAllocator, pParseContext);
+      FXTARGET_DeleteWith(CXFA_TextParseContext, m_pAllocator.get(),
+                          pParseContext);
   }
   m_mapXMLNodeToParseContext.RemoveAll();
-  delete m_pAllocator;
-  m_pAllocator = nullptr;
+  m_pAllocator.reset();
 }
 void CXFA_TextParser::InitCSSData(CXFA_TextProvider* pTextProvider) {
   if (!pTextProvider)
     return;
 
   if (!m_pSelector) {
     CXFA_FFDoc* pDoc = pTextProvider->GetDocNode();
     IFX_FontMgr* pFontMgr = pDoc->GetApp()->GetFDEFontMgr();
     ASSERT(pFontMgr);
     m_pSelector.reset(new CFDE_CSSStyleSelector);
@@ skipping 129 matching lines @@
   m_pSelector->ComputeStyle(&tagProvider, pContext->GetDecls(),
                             pContext->CountDecls(), pStyle);
   pCSSAccel->OnLeaveTag(&tagProvider);
   return pStyle;
 }
 void CXFA_TextParser::DoParse(CFDE_XMLNode* pXMLContainer,
                               CXFA_TextProvider* pTextProvider) {
   if (pXMLContainer == NULL || pTextProvider == NULL || m_pAllocator) {
     return;
   }
-  m_pAllocator = IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Fixed, 32,
-                                             sizeof(CXFA_CSSTagProvider));
+  m_pAllocator.reset(IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Fixed, 32,
+                                                 sizeof(CXFA_CSSTagProvider)));
   InitCSSData(pTextProvider);
   IFDE_CSSComputedStyle* pRootStyle = CreateRootStyle(pTextProvider);
   ParseRichText(pXMLContainer, pRootStyle);
   pRootStyle->Release();
 }
 void CXFA_TextParser::ParseRichText(CFDE_XMLNode* pXMLNode,
                                     IFDE_CSSComputedStyle* pParentStyle) {
   if (!pXMLNode)
     return;
 
   CXFA_CSSTagProvider tagProvider;
   ParseTagInfo(pXMLNode, tagProvider);
   if (!tagProvider.m_bTagAvailable)
     return;
 
   IFDE_CSSComputedStyle* pNewStyle = NULL;
   if ((tagProvider.GetTagName() != FX_WSTRC(L"body")) ||
       (tagProvider.GetTagName() != FX_WSTRC(L"html"))) {
     CXFA_TextParseContext* pTextContext =
-        FXTARGET_NewWith(m_pAllocator) CXFA_TextParseContext;
+        FXTARGET_NewWith(m_pAllocator.get()) CXFA_TextParseContext;
     FDE_CSSDISPLAY eDisplay = FDE_CSSDISPLAY_Inline;
     if (!tagProvider.m_bContent) {
       pNewStyle = CreateStyle(pParentStyle);
       CFDE_CSSAccelerator* pCSSAccel = m_pSelector->InitAccelerator();
       pCSSAccel->OnEnterTag(&tagProvider);
       CFDE_CSSDeclarationArray DeclArray;
       int32_t iMatchedDecls =
           m_pSelector->MatchDeclarations(&tagProvider, DeclArray);
       const CFDE_CSSDeclaration** ppMatchDecls =
           const_cast<const CFDE_CSSDeclaration**>(DeclArray.GetData());
@@ skipping 411 matching lines @@
       m_pBreak(nullptr),
       m_pLoader(nullptr),
       m_iLines(0),
       m_fMaxWidth(0),
       m_pTabstopContext(nullptr),
       m_bBlockContinue(TRUE) {
   ASSERT(m_pTextProvider);
 }
 CXFA_TextLayout::~CXFA_TextLayout() {
   m_textParser.Reset();
-  delete m_pLoader;
-  delete m_pTabstopContext;
   Unload();
 }
 void CXFA_TextLayout::Unload() {
   int32_t iCount = m_pieceLines.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_PieceLine* pLine = m_pieceLines.GetAt(i);
-    FXTARGET_DeleteWith(CXFA_PieceLine, m_pAllocator, pLine);
+    FXTARGET_DeleteWith(CXFA_PieceLine, m_pAllocator.get(), pLine);
   }
   m_pieceLines.RemoveAll();
-  if (m_pBreak) {
-    m_pBreak->Release();
-    m_pBreak = NULL;
-  }
-  delete m_pAllocator;
-  m_pAllocator = nullptr;
+  m_pBreak.reset();
+  m_pAllocator.reset();
 }
 const CXFA_PieceLineArray* CXFA_TextLayout::GetPieceLines() {
   return &m_pieceLines;
 }
 void CXFA_TextLayout::GetTextDataNode() {
   if (m_pTextProvider == NULL) {
     return;
   }
   CXFA_Node* pNode = m_pTextProvider->GetTextNode(m_bRichText);
   if (pNode && m_bRichText) {
@@ skipping 150 matching lines @@
         pStyle->GetBoundaryStyles()->SetMarginWidth(pNewRect);
       }
     }
     m_pBreak->SetLineBoundary(fStart, fLineWidth);
     FX_FLOAT fIndent = pParaStyle->GetTextIndent().GetValue();
     if (fIndent > 0) {
       fStart += fIndent;
     }
     m_pBreak->SetLineStartPos(fStart);
     m_pBreak->SetTabWidth(m_textParser.GetTabInterval(pStyle));
-    if (m_pTabstopContext == NULL) {
-      m_pTabstopContext = new CXFA_TextTabstopsContext;
-    }
-    m_textParser.GetTabstops(pStyle, m_pTabstopContext);
+    if (!m_pTabstopContext)
+      m_pTabstopContext.reset(new CXFA_TextTabstopsContext);
+    m_textParser.GetTabstops(pStyle, m_pTabstopContext.get());
     for (int32_t i = 0; i < m_pTabstopContext->m_iTabCount; i++) {
       XFA_TABSTOPS* pTab = m_pTabstopContext->m_tabstops.GetDataPtr(i);
       m_pBreak->AddPositionedTab(pTab->fTabstops);
     }
   }
   FX_FLOAT fFontSize = m_textParser.GetFontSize(m_pTextProvider, pStyle);
   m_pBreak->SetFontSize(fFontSize);
   m_pBreak->SetLineBreakTolerance(fFontSize * 0.2f);
   m_pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, pStyle));
   m_pBreak->SetHorizontalScale(
@@ skipping 27 matching lines @@
   FX_FLOAT fHeight = m_pLoader->m_fHeight;
   if (fHeight < 0.1f) {
     fHeight = 0;
     for (int32_t i = 0; i < iCount; i++) {
       fHeight += m_pLoader->m_lineHeights.ElementAt(i);
     }
   }
   return fHeight;
 }
 FX_FLOAT CXFA_TextLayout::StartLayout(FX_FLOAT fWidth) {
-  if (m_pLoader == NULL) {
-    m_pLoader = new CXFA_LoaderContext;
-  }
+  if (!m_pLoader)
+    m_pLoader.reset(new CXFA_LoaderContext);
+
   if (fWidth < 0 || (m_pLoader->m_fWidth > -1 &&
                      FXSYS_fabs(fWidth - m_pLoader->m_fWidth) > 0)) {
     m_pLoader->m_lineHeights.RemoveAll();
     m_Blocks.RemoveAll();
     Unload();
     m_pLoader->m_fStartLineOffset = 0;
   }
   m_pLoader->m_fWidth = fWidth;
   if (fWidth < 0) {
     CFX_SizeF szMax;
@@ skipping 88 matching lines @@
 }
 int32_t CXFA_TextLayout::CountBlocks() const {
   int32_t iCount = m_Blocks.GetSize() / 2;
   return iCount > 0 ? iCount : 1;
 }
 
 FX_BOOL CXFA_TextLayout::CalcSize(const CFX_SizeF& minSize,
                                   const CFX_SizeF& maxSize,
                                   CFX_SizeF& defaultSize) {
   defaultSize.x = maxSize.x;
-  if (defaultSize.x < 1) {
+  if (defaultSize.x < 1)
     defaultSize.x = 0xFFFF;
-  }
-  if (m_pBreak)
-    m_pBreak->Release();
 
-  m_pBreak = CreateBreak(FALSE);
+  m_pBreak.reset(CreateBreak(FALSE));
   FX_FLOAT fLinePos = 0;
   m_iLines = 0;
   m_fMaxWidth = 0;
   Loader(defaultSize, fLinePos, FALSE);
-  if (fLinePos < 0.1f) {
+  if (fLinePos < 0.1f)
     fLinePos = m_textParser.GetFontSize(m_pTextProvider, NULL);
-  }
-  delete m_pTabstopContext;
-  m_pTabstopContext = nullptr;
+
+  m_pTabstopContext.reset();
   defaultSize = CFX_SizeF(m_fMaxWidth, fLinePos);
   return TRUE;
 }
 
 FX_BOOL CXFA_TextLayout::Layout(const CFX_SizeF& size, FX_FLOAT* fHeight) {
-  if (size.x < 1) {
+  if (size.x < 1)
     return FALSE;
-  }
+
   Unload();
-  m_pBreak = CreateBreak(TRUE);
+  m_pBreak.reset(CreateBreak(TRUE));
   if (m_pLoader) {
     m_pLoader->m_iTotalLines = -1;
     m_pLoader->m_iChar = 0;
   }
   m_iLines = 0;
   FX_FLOAT fLinePos = 0;
   Loader(size, fLinePos, TRUE);
   UpdateAlign(size.y, fLinePos);
-  delete m_pTabstopContext;
-  m_pTabstopContext = nullptr;
+  m_pTabstopContext.reset();
   if (fHeight)
     *fHeight = fLinePos;
   return TRUE;
 }
 
 FX_BOOL CXFA_TextLayout::Layout(int32_t iBlock) {
   if (m_pLoader == NULL || iBlock < 0 || iBlock >= CountBlocks()) {
     return FALSE;
   }
   if (m_pLoader->m_fWidth < 1) {
     return FALSE;
   }
   m_pLoader->m_iTotalLines = -1;
   m_iLines = 0;
   FX_FLOAT fLinePos = 0;
   CXFA_Node* pNode = NULL;
   CFX_SizeF szText(m_pLoader->m_fWidth, m_pLoader->m_fHeight);
   int32_t iCount = m_Blocks.GetSize();
   int32_t iBlocksHeightCount = m_pLoader->m_BlocksHeight.GetSize();
   iBlocksHeightCount /= 2;
   if (iBlock < iBlocksHeightCount) {
     return TRUE;
   }
   if (iBlock == iBlocksHeightCount) {
     Unload();
-    m_pBreak = CreateBreak(TRUE);
+    m_pBreak.reset(CreateBreak(TRUE));
     fLinePos = m_pLoader->m_fStartLineOffset;
     for (int32_t i = 0; i < iBlocksHeightCount; i++) {
       fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
     }
     m_pLoader->m_iChar = 0;
     if (iCount > 1) {
       m_pLoader->m_iTotalLines = m_Blocks.ElementAt(iBlock * 2 + 1);
     }
     Loader(szText, fLinePos, TRUE);
     if (iCount == 0 && m_pLoader->m_fStartLineOffset < 0.1f) {
@@ skipping 50 matching lines @@
       }
     } else {
       pNode = m_pLoader->m_pNode;
       if (pNode == NULL) {
         return TRUE;
       }
       LoadText(pNode, szText, fLinePos, TRUE);
     }
   }
   if (iBlock == iCount) {
-    delete m_pTabstopContext;
-    m_pTabstopContext = nullptr;
-    delete m_pLoader;
-    m_pLoader = nullptr;
+    m_pTabstopContext.reset();
+    m_pLoader.reset();
   }
   return TRUE;
 }
 void CXFA_TextLayout::ItemBlocks(const CFX_RectF& rtText, int32_t iBlockIndex) {
   if (!m_pLoader) {
     return;
   }
   int32_t iCountHeight = m_pLoader->m_lineHeights.GetSize();
   if (iCountHeight == 0) {
     return;
@@ skipping 114 matching lines @@
     for (int32_t j = 0; j < iPieces; j++) {
       XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(j);
       CFX_RectF& rect = pPiece->rtPiece;
       rect.top += fHeight;
     }
   }
 }
 FX_BOOL CXFA_TextLayout::Loader(const CFX_SizeF& szText,
                                 FX_FLOAT& fLinePos,
                                 FX_BOOL bSavePieces) {
-  if (!m_pAllocator)
-    m_pAllocator = IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 256, 0);
+  if (!m_pAllocator) {
+    m_pAllocator.reset(
+        IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 256, 0));
+  }
+  GetTextDataNode();
+  if (!m_pTextDataNode)
+    return TRUE;
 
-  GetTextDataNode();
-  if (m_pTextDataNode == NULL) {
-    return TRUE;
-  }
   if (m_bRichText) {
     CFDE_XMLNode* pXMLContainer = GetXMLContainerNode();
     if (pXMLContainer) {
       if (!m_textParser.IsParsed()) {
         m_textParser.DoParse(pXMLContainer, m_pTextProvider);
       }
       IFDE_CSSComputedStyle* pRootStyle =
           m_textParser.CreateRootStyle(m_pTextProvider);
       LoadRichText(pXMLContainer, szText, fLinePos, pRootStyle, bSavePieces);
       pRootStyle->Release();
@@ skipping 93 matching lines @@
           if (pRect) {
             fLinePos += pRect->top.GetValue();
             fSpaceBelow = pRect->bottom.GetValue();
           }
         }
         if (wsName == FX_WSTRC(L"a")) {
           CFX_WideString wsLinkContent;
           ASSERT(pElement);
           pElement->GetString(L"href", wsLinkContent);
           if (!wsLinkContent.IsEmpty()) {
-            pLinkData = FXTARGET_NewWith(m_pAllocator) CXFA_LinkUserData(
-                m_pAllocator,
+            pLinkData = FXTARGET_NewWith(m_pAllocator.get()) CXFA_LinkUserData(
+                m_pAllocator.get(),
                 wsLinkContent.GetBuffer(wsLinkContent.GetLength()));
             wsLinkContent.ReleaseBuffer(wsLinkContent.GetLength());
           }
         }
         int32_t iTabCount =
             m_textParser.CountTabs(bContentNode ? pParentStyle : pStyle);
         FX_BOOL bSpaceRun =
             m_textParser.IsSpaceRun(bContentNode ? pParentStyle : pStyle);
         CFX_WideString wsText;
         if (bContentNode && iTabCount == 0) {
@@ skipping 34 matching lines @@
             m_pLoader->m_dwFlags |= XFA_LOADERCNTXTFLG_FILTERSPACE;
           } else if (wsText.GetLength() != 0) {
             m_pLoader->m_dwFlags &= ~XFA_LOADERCNTXTFLG_FILTERSPACE;
           }
         }
         if (wsText.GetLength() > 0) {
           if (m_pLoader == NULL || m_pLoader->m_iChar == 0) {
             if (pLinkData) {
               pLinkData->AddRef();
             }
-            CXFA_TextUserData* pUserData = FXTARGET_NewWith(m_pAllocator)
-                CXFA_TextUserData(m_pAllocator,
+            CXFA_TextUserData* pUserData = FXTARGET_NewWith(m_pAllocator.get())
+                CXFA_TextUserData(m_pAllocator.get(),
                                   bContentNode ? pParentStyle : pStyle,
                                   pLinkData);
             m_pBreak->SetUserData(pUserData);
           }
           if (AppendChar(wsText, fLinePos, 0, bSavePieces)) {
             if (m_pLoader) {
               m_pLoader->m_dwFlags &= ~XFA_LOADERCNTXTFLG_FILTERSPACE;
             }
             if (IsEnd(bSavePieces)) {
               if (m_pLoader && m_pLoader->m_iTotalLines > -1) {
@@ skipping 202 matching lines @@
 void CXFA_TextLayout::AppendTextLine(uint32_t dwStatus,
                                      FX_FLOAT& fLinePos,
                                      FX_BOOL bSavePieces,
                                      FX_BOOL bEndBreak) {
   int32_t iPieces = m_pBreak->CountBreakPieces();
   if (iPieces < 1) {
     return;
   }
   IFDE_CSSComputedStyle* pStyle = NULL;
   if (bSavePieces) {
-    CXFA_PieceLine* pPieceLine = FXTARGET_NewWith(m_pAllocator) CXFA_PieceLine;
+    CXFA_PieceLine* pPieceLine =
+        FXTARGET_NewWith(m_pAllocator.get()) CXFA_PieceLine;
     m_pieceLines.Add(pPieceLine);
     if (m_pTabstopContext) {
       m_pTabstopContext->Reset();
     }
     FX_FLOAT fLineStep = 0, fBaseLine = 0;
     int32_t i = 0;
     for (i = 0; i < iPieces; i++) {
       const CFX_RTFPiece* pPiece = m_pBreak->GetBreakPiece(i);
       CXFA_TextUserData* pUserData = (CXFA_TextUserData*)pPiece->m_pUserData;
       if (pUserData)
         pStyle = pUserData->m_pStyle;
       FX_FLOAT fVerScale = pPiece->m_iVerticalScale / 100.0f;
-      XFA_TextPiece* pTP = FXTARGET_NewWith(m_pAllocator) XFA_TextPiece();
+      XFA_TextPiece* pTP = FXTARGET_NewWith(m_pAllocator.get()) XFA_TextPiece();
       pTP->pszText =
           (FX_WCHAR*)m_pAllocator->Alloc(pPiece->m_iChars * sizeof(FX_WCHAR));
       pTP->pWidths =
           (int32_t*)m_pAllocator->Alloc(pPiece->m_iChars * sizeof(int32_t));
       pTP->iChars = pPiece->m_iChars;
       pPiece->GetString(pTP->pszText);
       pPiece->GetWidths(pTP->pWidths);
       pTP->iBidiLevel = pPiece->m_iBidiLevel;
       pTP->iHorScale = pPiece->m_iHorizontalScale;
       pTP->iVerScale = pPiece->m_iVerticalScale;
@@ skipping 260 matching lines @@
   tr.iLength = iLength;
   tr.fFontSize = pPiece->fFontSize;
   tr.iBidiLevel = pPiece->iBidiLevel;
   tr.iCharRotation = 0;
   tr.wLineBreakChar = L'\n';
   tr.iVerticalScale = pPiece->iVerScale;
   tr.dwLayoutStyles = FX_RTFLAYOUTSTYLE_ExpandTab;
   tr.iHorizontalScale = pPiece->iHorScale;
   return TRUE;
 }