Remove NULL in xfa/

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 101 matching lines @@
 }
 
 CXFA_LoaderContext::CXFA_LoaderContext()
     : m_bSaveLineHeight(FALSE),
       m_fWidth(0),
       m_fHeight(0),
       m_fLastPos(0),
       m_fStartLineOffset(0),
       m_iChar(0),
       m_iTotalLines(-1),
-      m_pXMLNode(NULL),
-      m_pNode(NULL),
-      m_pParentStyle(NULL),
+      m_pXMLNode(nullptr),
+      m_pNode(nullptr),
+      m_pParentStyle(nullptr),
       m_dwFlags(0) {}
 
 CXFA_LoaderContext::~CXFA_LoaderContext() {}
 
 IFDE_CSSStyleSheet* CXFA_TextParser::LoadDefaultSheetStyle() {
   static const FX_WCHAR s_pStyle[] =
       L"html,body,ol,p,ul{display:block}"
       L"li{display:list-item}"
       L"ol,ul{padding-left:33px}ol{list-style-type:decimal}ol,ul{margin-top:0;"
       L"margin-bottom:0}ul,ol{margin:1.12em 0}"
       L"a{color:#0000ff;text-decoration:underline}b{font-weight:bolder}i{font-"
       L"style:italic}"
       L"sup{vertical-align:+15em;font-size:.66em}sub{vertical-align:-15em;font-"
       L"size:.66em}";
   return IFDE_CSSStyleSheet::LoadFromBuffer(
       CFX_WideString(), s_pStyle, FXSYS_wcslen(s_pStyle), FX_CODEPAGE_UTF8);
 }
 IFDE_CSSComputedStyle* CXFA_TextParser::CreateRootStyle(
     CXFA_TextProvider* pTextProvider) {
   CXFA_Font font = pTextProvider->GetFontNode();
   CXFA_Para para = pTextProvider->GetParaNode();
-  IFDE_CSSComputedStyle* pStyle = m_pSelector->CreateComputedStyle(NULL);
+  IFDE_CSSComputedStyle* pStyle = m_pSelector->CreateComputedStyle(nullptr);
   IFDE_CSSFontStyle* pFontStyle = pStyle->GetFontStyles();
   IFDE_CSSParagraphStyle* pParaStyle = pStyle->GetParagraphStyles();
   FX_FLOAT fLineHeight = 0, fFontSize = 10;
   if (para) {
     fLineHeight = para.GetLineHeight();
     FDE_CSSLENGTH indent;
     indent.Set(FDE_CSSLENGTHUNIT_Point, para.GetTextIndent());
     pParaStyle->SetTextIndent(indent);
     FDE_CSSTEXTALIGN hAlign = FDE_CSSTEXTALIGN_Left;
     switch (para.GetHorizontalAlign()) {
@@ skipping 84 matching lines @@
   IFDE_CSSComputedStyle* pStyle = CreateStyle(pParentStyle);
   CFDE_CSSAccelerator* pCSSAccel = m_pSelector->InitAccelerator();
   pCSSAccel->OnEnterTag(&tagProvider);
   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) {
+  if (!pXMLContainer || !pTextProvider || m_pAllocator) {
     return;
   }
   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;
+  IFDE_CSSComputedStyle* pNewStyle = nullptr;
   if ((tagProvider.GetTagName() != FX_WSTRC(L"body")) ||
       (tagProvider.GetTagName() != FX_WSTRC(L"html"))) {
     CXFA_TextParseContext* pTextContext =
         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;
@@ skipping 256 matching lines @@
   } else if (fLineHeight < 0.1f) {
     fLineHeight = GetFontSize(pTextProvider, pStyle) * 1.2f;
   }
   fLineHeight *= fVerScale;
   return fLineHeight;
 }
 FX_BOOL CXFA_TextParser::GetEmbbedObj(CXFA_TextProvider* pTextProvider,
                                       CFDE_XMLNode* pXMLNode,
                                       CFX_WideString& wsValue) {
   wsValue.clear();
-  if (pXMLNode == NULL) {
+  if (!pXMLNode) {
     return FALSE;
   }
   FX_BOOL bRet = FALSE;
   if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
     CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLNode);
     CFX_WideString wsAttr;
     pElement->GetString(L"xfa:embed", wsAttr);
     if (wsAttr.IsEmpty()) {
       return FALSE;
     }
@@ skipping 36 matching lines @@
   XFA_TABSTOPSSTATUS_EOS,
   XFA_TABSTOPSSTATUS_None,
   XFA_TABSTOPSSTATUS_Alignment,
   XFA_TABSTOPSSTATUS_StartLeader,
   XFA_TABSTOPSSTATUS_Leader,
   XFA_TABSTOPSSTATUS_Location,
 };
 FX_BOOL CXFA_TextParser::GetTabstops(
     IFDE_CSSComputedStyle* pStyle,
     CXFA_TextTabstopsContext* pTabstopContext) {
-  if (pStyle == NULL || pTabstopContext == NULL) {
+  if (!pStyle || !pTabstopContext) {
     return FALSE;
   }
   CFX_WideString wsValue;
   if (!pStyle->GetCustomStyle(FX_WSTRC(L"xfa-tab-stops"), wsValue) &&
       !pStyle->GetCustomStyle(FX_WSTRC(L"tab-stops"), wsValue)) {
     return FALSE;
   }
   int32_t iLength = wsValue.GetLength();
   const FX_WCHAR* pTabStops = wsValue.c_str();
   int32_t iCur = 0;
@@ skipping 93 matching lines @@
     FXTARGET_DeleteWith(CXFA_PieceLine, m_pAllocator.get(), pLine);
   }
   m_pieceLines.RemoveAll();
   m_pBreak.reset();
   m_pAllocator.reset();
 }
 const CXFA_PieceLineArray* CXFA_TextLayout::GetPieceLines() {
   return &m_pieceLines;
 }
 void CXFA_TextLayout::GetTextDataNode() {
-  if (m_pTextProvider == NULL) {
+  if (!m_pTextProvider) {
     return;
   }
   CXFA_Node* pNode = m_pTextProvider->GetTextNode(m_bRichText);
   if (pNode && m_bRichText) {
     m_textParser.Reset();
   }
   m_pTextDataNode = pNode;
 }
 CFDE_XMLNode* CXFA_TextLayout::GetXMLContainerNode() {
-  CFDE_XMLNode* pXMLContainer = NULL;
+  CFDE_XMLNode* pXMLContainer = nullptr;
   if (m_bRichText) {
     CFDE_XMLNode* pXMLRoot = m_pTextDataNode->GetXMLMappingNode();
     if (!pXMLRoot) {
       return pXMLContainer;
     }
     for (CFDE_XMLNode* pXMLChild =
              pXMLRoot->GetNodeItem(CFDE_XMLNode::FirstChild);
          pXMLChild;
          pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
       if (pXMLChild->GetType() == FDE_XMLNODE_Element) {
@@ skipping 11 matching lines @@
 }
 CFX_RTFBreak* CXFA_TextLayout::CreateBreak(FX_BOOL bDefault) {
   uint32_t dwStyle = FX_RTFLAYOUTSTYLE_ExpandTab;
   if (!bDefault) {
     dwStyle |= FX_RTFLAYOUTSTYLE_Pagination;
   }
   CFX_RTFBreak* pBreak = new CFX_RTFBreak(0);
   pBreak->SetLayoutStyles(dwStyle);
   pBreak->SetLineBreakChar(L'\n');
   pBreak->SetLineBreakTolerance(1);
-  pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, NULL));
-  pBreak->SetFontSize(m_textParser.GetFontSize(m_pTextProvider, NULL));
+  pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, nullptr));
+  pBreak->SetFontSize(m_textParser.GetFontSize(m_pTextProvider, nullptr));
   return pBreak;
 }
 void CXFA_TextLayout::InitBreak(FX_FLOAT fLineWidth) {
   CXFA_Font font = m_pTextProvider->GetFontNode();
   CXFA_Para para = m_pTextProvider->GetParaNode();
   FX_FLOAT fStart = 0;
   FX_FLOAT fStartPos = 0;
   if (para) {
     int32_t iAlign = FX_RTFLINEALIGNMENT_Left;
     switch (para.GetHorizontalAlign()) {
@@ skipping 28 matching lines @@
       fStartPos += fIndent;
     }
   }
   m_pBreak->SetLineBoundary(fStart, fLineWidth);
   m_pBreak->SetLineStartPos(fStartPos);
   if (font) {
     m_pBreak->SetHorizontalScale((int32_t)font.GetHorizontalScale());
     m_pBreak->SetVerticalScale((int32_t)font.GetVerticalScale());
     m_pBreak->SetCharSpace(font.GetLetterSpacing());
   }
-  FX_FLOAT fFontSize = m_textParser.GetFontSize(m_pTextProvider, NULL);
+  FX_FLOAT fFontSize = m_textParser.GetFontSize(m_pTextProvider, nullptr);
   m_pBreak->SetFontSize(fFontSize);
-  m_pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, NULL));
+  m_pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, nullptr));
   m_pBreak->SetLineBreakTolerance(fFontSize * 0.2f);
 }
 void CXFA_TextLayout::InitBreak(IFDE_CSSComputedStyle* pStyle,
                                 FDE_CSSDISPLAY eDisplay,
                                 FX_FLOAT fLineWidth,
                                 CFDE_XMLNode* pXMLNode,
                                 IFDE_CSSComputedStyle* pParentStyle) {
-  if (pStyle == NULL) {
+  if (!pStyle) {
     InitBreak(fLineWidth);
     return;
   }
   IFDE_CSSParagraphStyle* pParaStyle = pStyle->GetParagraphStyles();
   if (eDisplay == FDE_CSSDISPLAY_Block || eDisplay == FDE_CSSDISPLAY_ListItem) {
     int32_t iAlign = FX_RTFLINEALIGNMENT_Left;
     switch (pParaStyle->GetTextAlign()) {
       case FDE_CSSTEXTALIGN_Right:
         iAlign = FX_RTFLINEALIGNMENT_Right;
         break;
@@ skipping 69 matching lines @@
 int32_t CXFA_TextLayout::GetText(CFX_WideString& wsText) {
   GetTextDataNode();
   wsText.clear();
   if (m_bRichText) {
   } else {
     wsText = m_pTextDataNode->GetContent();
   }
   return wsText.GetLength();
 }
 FX_FLOAT CXFA_TextLayout::GetLayoutHeight() {
-  if (m_pLoader == NULL) {
+  if (!m_pLoader) {
     return 0;
   }
   int32_t iCount = m_pLoader->m_lineHeights.GetSize();
   if (iCount == 0 && m_pLoader->m_fWidth > 0) {
     CFX_SizeF szMax(m_pLoader->m_fWidth, m_pLoader->m_fHeight);
     CFX_SizeF szDef;
     m_pLoader->m_bSaveLineHeight = TRUE;
     m_pLoader->m_fLastPos = 0;
     CalcSize(szMax, szMax, szDef);
     m_pLoader->m_bSaveLineHeight = FALSE;
@@ skipping 28 matching lines @@
     CalcSize(szMax, szMax, szDef);
     m_pLoader->m_bSaveLineHeight = FALSE;
     fWidth = szDef.x;
   }
   return fWidth;
 }
 FX_BOOL CXFA_TextLayout::DoLayout(int32_t iBlockIndex,
                                   FX_FLOAT& fCalcHeight,
                                   FX_FLOAT fContentAreaHeight,
                                   FX_FLOAT fTextHeight) {
-  if (m_pLoader == NULL) {
+  if (!m_pLoader) {
     return FALSE;
   }
   int32_t iBlockCount = m_Blocks.GetSize();
   FX_FLOAT fHeight = fTextHeight;
   if (fHeight < 0) {
     fHeight = GetLayoutHeight();
   }
   m_pLoader->m_fHeight = fHeight;
   if (fContentAreaHeight < 0) {
     return FALSE;
@@ skipping 73 matching lines @@
   defaultSize.x = maxSize.x;
   if (defaultSize.x < 1)
     defaultSize.x = 0xFFFF;
 
   m_pBreak.reset(CreateBreak(FALSE));
   FX_FLOAT fLinePos = 0;
   m_iLines = 0;
   m_fMaxWidth = 0;
   Loader(defaultSize, fLinePos, FALSE);
   if (fLinePos < 0.1f)
-    fLinePos = m_textParser.GetFontSize(m_pTextProvider, NULL);
+    fLinePos = m_textParser.GetFontSize(m_pTextProvider, 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)
     return FALSE;
 
   Unload();
   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);
   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())
+  if (!m_pLoader || 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;
+  CXFA_Node* pNode = nullptr;
   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.reset(CreateBreak(TRUE));
     fLinePos = m_pLoader->m_fStartLineOffset;
@@ skipping 25 matching lines @@
         if (!LoadRichText(pXMLNode, szText, fLinePos, m_pLoader->m_pParentStyle,
                           TRUE)) {
           break;
         }
       }
       while (!pXMLNode) {
         pXMLNode = pSaveXMLNode->GetNodeItem(CFDE_XMLNode::Parent);
         if (pXMLNode == pContainerNode)
           break;
         if (!LoadRichText(pXMLNode, szText, fLinePos, m_pLoader->m_pParentStyle,
-                          TRUE, NULL, FALSE)) {
+                          TRUE, nullptr, FALSE)) {
           break;
         }
         pSaveXMLNode = pXMLNode;
         pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling);
         if (!pXMLNode)
           continue;
         for (; pXMLNode;
              pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
           if (!LoadRichText(pXMLNode, szText, fLinePos,
                             m_pLoader->m_pParentStyle, TRUE)) {
@@ skipping 68 matching lines @@
   pDevice->SetClipRect(rtClip);
 
   std::unique_ptr<CFDE_Brush> pSolidBrush(new CFDE_Brush);
   std::unique_ptr<CFDE_Pen> pPen(new CFDE_Pen);
   if (m_pieceLines.GetSize() == 0) {
     int32_t iBlockCount = CountBlocks();
     for (int32_t i = 0; i < iBlockCount; i++) {
       Layout(i);
     }
   }
-  FXTEXT_CHARPOS* pCharPos = NULL;
+  FXTEXT_CHARPOS* pCharPos = nullptr;
   int32_t iCharCount = 0;
   int32_t iLineStart = 0;
   int32_t iPieceLines = m_pieceLines.GetSize();
   int32_t iCount = m_Blocks.GetSize();
   if (iCount > 0) {
     iBlock *= 2;
     if (iBlock < iCount) {
       iLineStart = m_Blocks.ElementAt(iBlock);
       iPieceLines = m_Blocks.ElementAt(iBlock + 1);
     } else {
@@ skipping 113 matching lines @@
 }
 FX_BOOL CXFA_TextLayout::LoadRichText(CFDE_XMLNode* pXMLNode,
                                       const CFX_SizeF& szText,
                                       FX_FLOAT& fLinePos,
                                       IFDE_CSSComputedStyle* pParentStyle,
                                       FX_BOOL bSavePieces,
                                       CXFA_LinkUserData* pLinkData,
                                       FX_BOOL bEndBreak,
                                       FX_BOOL bIsOl,
                                       int32_t iLiCount) {
-  if (pXMLNode == NULL) {
+  if (!pXMLNode) {
     return FALSE;
   }
   CXFA_TextParseContext* pContext =
       m_textParser.GetParseContextFromMap(pXMLNode);
   FDE_CSSDISPLAY eDisplay = FDE_CSSDISPLAY_None;
   FX_BOOL bContentNode = FALSE;
   FX_FLOAT fSpaceBelow = 0;
-  IFDE_CSSComputedStyle* pStyle = NULL;
+  IFDE_CSSComputedStyle* pStyle = nullptr;
   CFX_WideString wsName;
   if (bEndBreak) {
     FX_BOOL bCurOl = FALSE;
     FX_BOOL bCurLi = FALSE;
-    CFDE_XMLElement* pElement = NULL;
+    CFDE_XMLElement* pElement = nullptr;
     if (pContext) {
       if (m_bBlockContinue ||
           (m_pLoader && pXMLNode == m_pLoader->m_pXMLNode)) {
         m_bBlockContinue = TRUE;
       }
       if (pXMLNode->GetType() == FDE_XMLNODE_Text) {
         bContentNode = TRUE;
       } else if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
         pElement = static_cast<CFDE_XMLElement*>(pXMLNode);
         pElement->GetLocalTagName(wsName);
@@ skipping 75 matching lines @@
                      (m_pLoader->m_dwFlags & XFA_LOADERCNTXTFLG_FILTERSPACE)) {
             m_pLoader->m_dwFlags &= ~XFA_LOADERCNTXTFLG_FILTERSPACE;
           } else if (wsText.GetLength() > 0 &&
                      (0x20 == wsText.GetAt(wsText.GetLength() - 1))) {
             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 (!m_pLoader || m_pLoader->m_iChar == 0) {
             if (pLinkData) {
               pLinkData->Retain();
             }
             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)) {
@@ skipping 143 matching lines @@
 void CXFA_TextLayout::EndBreak(uint32_t dwStatus,
                                FX_FLOAT& fLinePos,
                                FX_BOOL bSavePieces) {
   dwStatus = m_pBreak->EndBreak(dwStatus);
   if (dwStatus > FX_RTFBREAK_PieceBreak) {
     AppendTextLine(dwStatus, fLinePos, bSavePieces, TRUE);
   }
 }
 void CXFA_TextLayout::DoTabstops(IFDE_CSSComputedStyle* pStyle,
                                  CXFA_PieceLine* pPieceLine) {
-  if (m_pTabstopContext == NULL || m_pTabstopContext->m_iTabCount == 0) {
+  if (!m_pTabstopContext || m_pTabstopContext->m_iTabCount == 0) {
     return;
   }
-  if (pStyle == NULL || pPieceLine == NULL) {
+  if (!pStyle || !pPieceLine) {
     return;
   }
   int32_t iPieces = pPieceLine->m_textPieces.GetSize();
   if (iPieces == 0) {
     return;
   }
   XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(iPieces - 1);
   int32_t& iTabstopsIndex = m_pTabstopContext->m_iTabIndex;
   int32_t iCount = m_textParser.CountTabs(pStyle);
   if (iTabstopsIndex > m_pTabstopContext->m_iTabCount - 1) {
@@ skipping 38 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;
+  IFDE_CSSComputedStyle* pStyle = nullptr;
   if (bSavePieces) {
     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++) {
@@ skipping 36 matching lines @@
           fBaseLineTemp = 0;
         }
       } else if (fBaseLine < -fBaseLineTemp) {
         fBaseLine = -fBaseLineTemp;
       }
       fLineStep = std::max(fLineStep, fLineHeight);
       if (pUserData && pUserData->m_pLinkData) {
         pUserData->m_pLinkData->Retain();
         pTP->pLinkData = pUserData->m_pLinkData;
       } else {
-        pTP->pLinkData = NULL;
+        pTP->pLinkData = nullptr;
       }
       DoTabstops(pStyle, pPieceLine);
     }
     for (i = 0; i < iPieces; i++) {
       XFA_TextPiece* pTP = pPieceLine->m_textPieces.GetAt(i);
       FX_FLOAT& fTop = pTP->rtPiece.top;
       FX_FLOAT fBaseLineTemp = fTop;
       fTop = fLinePos + fLineStep - pTP->rtPiece.height - fBaseLineTemp;
       fTop = std::max(0.0f, fTop);
     }
@@ skipping 189 matching lines @@
       pPath->AddLine(pt1, pt2);
       fEndY += 2.0f;
     }
   }
   pDevice->DrawPath(pPen, 1, pPath.get(), &tmDoc2Device);
 }
 
 int32_t CXFA_TextLayout::GetDisplayPos(const XFA_TextPiece* pPiece,
                                        FXTEXT_CHARPOS* pCharPos,
                                        FX_BOOL bCharCode) {
-  if (pPiece == NULL) {
+  if (!pPiece) {
     return 0;
   }
   FX_RTFTEXTOBJ tr;
   if (!ToRun(pPiece, tr)) {
     return 0;
   }
   return m_pBreak->GetDisplayPos(&tr, pCharPos, bCharCode);
 }
 FX_BOOL CXFA_TextLayout::ToRun(const XFA_TextPiece* pPiece, FX_RTFTEXTOBJ& tr) {
   int32_t iLength = pPiece->iChars;
@@ skipping 110 matching lines @@
   m_tabstops.RemoveAll();
   m_iTabCount = 0;
 }
 
 void CXFA_TextTabstopsContext::Reset() {
   m_iTabIndex = -1;
   m_bTabstops = FALSE;
   m_fTabWidth = 0;
   m_fLeft = 0;
 }