Remove NULL in xfa/

xfa/fxfa/parser/xfa_layout_itemlayout.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/parser/xfa_layout_itemlayout.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 65 matching lines @@
                          m_pFormNode->GetElementType() == XFA_Element::Form));
   m_pOldLayoutItem =
       (CXFA_ContentLayoutItem*)m_pFormNode->GetUserData(XFA_LAYOUTITEMKEY);
 }
 
 CXFA_ItemLayoutProcessor::~CXFA_ItemLayoutProcessor() {}
 
 CXFA_ContentLayoutItem* CXFA_ItemLayoutProcessor::CreateContentLayoutItem(
     CXFA_Node* pFormNode) {
   if (!pFormNode) {
-    return NULL;
+    return nullptr;
   }
-  CXFA_ContentLayoutItem* pLayoutItem = NULL;
+  CXFA_ContentLayoutItem* pLayoutItem = nullptr;
   if (m_pOldLayoutItem) {
     pLayoutItem = m_pOldLayoutItem;
     m_pOldLayoutItem = m_pOldLayoutItem->m_pNext;
     return pLayoutItem;
   }
   pLayoutItem = (CXFA_ContentLayoutItem*)pFormNode->GetDocument()
                     ->GetParser()
                     ->GetNotify()
                     ->OnCreateLayoutItem(pFormNode);
   CXFA_ContentLayoutItem* pPrevLayoutItem =
@@ skipping 101 matching lines @@
     return eLayoutMode;
   }
   CXFA_Node* pParentNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (pParentNode && pParentNode->GetElementType() == XFA_Element::Form) {
     bRootForceTb = TRUE;
     return XFA_ATTRIBUTEENUM_Tb;
   }
   return XFA_ATTRIBUTEENUM_Position;
 }
 static FX_BOOL XFA_ExistContainerKeep(CXFA_Node* pCurNode, FX_BOOL bPreFind) {
-  if (pCurNode == NULL || !XFA_ItemLayoutProcessor_IsTakingSpace(pCurNode)) {
+  if (!pCurNode || !XFA_ItemLayoutProcessor_IsTakingSpace(pCurNode)) {
     return FALSE;
   }
   XFA_NODEITEM eItemType = XFA_NODEITEM_PrevSibling;
   if (!bPreFind) {
     eItemType = XFA_NODEITEM_NextSibling;
   }
   CXFA_Node* pPreContainer =
       pCurNode->GetNodeItem(eItemType, XFA_ObjectType::ContainerNode);
-  if (pPreContainer == NULL) {
+  if (!pPreContainer) {
     return FALSE;
   }
   CXFA_Node* pKeep = pCurNode->GetFirstChildByClass(XFA_Element::Keep);
   if (pKeep) {
     XFA_ATTRIBUTEENUM ePrevious;
     XFA_ATTRIBUTE eKeepType = XFA_ATTRIBUTE_Previous;
     if (!bPreFind) {
       eKeepType = XFA_ATTRIBUTE_Next;
     }
     if (pKeep->TryEnum(eKeepType, ePrevious, FALSE)) {
@@ skipping 48 matching lines @@
     bCalculateMargin = FALSE;
   }
   CXFA_Node* pMarginNode =
       pLayoutItem->m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   if (pMarginNode && bCalculateMargin) {
     fCurTopMargin =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
     fCurBottomMargin =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
   }
-  CXFA_ContentLayoutItem* pSecondLayoutItem = NULL;
+  CXFA_ContentLayoutItem* pSecondLayoutItem = nullptr;
   if (m_pCurChildPreprocessor &&
       m_pCurChildPreprocessor->m_pFormNode == pLayoutItem->m_pFormNode) {
     pSecondLayoutItem = m_pCurChildPreprocessor->CreateContentLayoutItem(
         pLayoutItem->m_pFormNode);
   } else {
     pSecondLayoutItem = CreateContentLayoutItem(pLayoutItem->m_pFormNode);
   }
   pSecondLayoutItem->m_sPos.x = pLayoutItem->m_sPos.x;
   pSecondLayoutItem->m_sSize.x = pLayoutItem->m_sSize.x;
   pSecondLayoutItem->m_sPos.y = 0;
@@ skipping 13 matching lines @@
         pParentItem = (CXFA_ContentLayoutItem*)pParentItem->m_pParent;
       }
     }
   } else {
     pSecondLayoutItem->m_pParent = pLayoutItem->m_pParent;
     pSecondLayoutItem->m_pNextSibling = pLayoutItem->m_pNextSibling;
     pLayoutItem->m_pNextSibling = pSecondLayoutItem;
   }
   CXFA_ContentLayoutItem* pChildren =
       (CXFA_ContentLayoutItem*)pLayoutItem->m_pFirstChild;
-  pLayoutItem->m_pFirstChild = NULL;
+  pLayoutItem->m_pFirstChild = nullptr;
   FX_FLOAT lHeightForKeep = 0;
   CFX_ArrayTemplate<CXFA_ContentLayoutItem*> keepLayoutItems;
   FX_FLOAT fAddMarginHeight = 0;
-  for (CXFA_ContentLayoutItem *pChildItem = pChildren, *pChildNext = NULL;
+  for (CXFA_ContentLayoutItem *pChildItem = pChildren, *pChildNext = nullptr;
        pChildItem; pChildItem = pChildNext) {
     pChildNext = (CXFA_ContentLayoutItem*)pChildItem->m_pNextSibling;
-    pChildItem->m_pNextSibling = NULL;
+    pChildItem->m_pNextSibling = nullptr;
     if (fSplitPos <= fCurTopMargin + pChildItem->m_sPos.y + fCurBottomMargin +
                          XFA_LAYOUT_FLOAT_PERCISION) {
       if (!XFA_ExistContainerKeep(pChildItem->m_pFormNode, TRUE)) {
         pChildItem->m_sPos.y -= fSplitPos - fCurBottomMargin;
         pChildItem->m_sPos.y += lHeightForKeep;
         pChildItem->m_sPos.y += fAddMarginHeight;
         pSecondLayoutItem->AddChild(pChildItem);
       } else {
         if (lHeightForKeep < XFA_LAYOUT_FLOAT_PERCISION) {
           for (int32_t iIndex = 0; iIndex < keepLayoutItems.GetSize();
@@ skipping 34 matching lines @@
       SplitLayoutItem(
           pChildItem, pSecondLayoutItem,
           fSplitPos - fCurTopMargin - fCurBottomMargin - pChildItem->m_sPos.y);
       fAddMarginHeight = pSecondLayoutItem->m_sSize.y - fOldHeight;
       pLayoutItem->AddChild(pChildItem);
     }
   }
 }
 void CXFA_ItemLayoutProcessor::SplitLayoutItem(FX_FLOAT fSplitPos) {
   ASSERT(m_pLayoutItem);
-  SplitLayoutItem(m_pLayoutItem, NULL, fSplitPos);
+  SplitLayoutItem(m_pLayoutItem, nullptr, fSplitPos);
 }
 
 CXFA_ContainerLayoutItem* CXFA_LayoutItem::GetPage() const {
   for (CXFA_LayoutItem* pCurNode = const_cast<CXFA_LayoutItem*>(this); pCurNode;
        pCurNode = pCurNode->m_pParent) {
     if (pCurNode->m_pFormNode->GetElementType() == XFA_Element::PageArea)
       return static_cast<CXFA_ContainerLayoutItem*>(pCurNode);
   }
   return nullptr;
 }
@@ skipping 115 matching lines @@
     iCount++;
   }
   return iCount;
 }
 
 void CXFA_LayoutItem::AddChild(CXFA_LayoutItem* pChildItem) {
   if (pChildItem->m_pParent) {
     pChildItem->m_pParent->RemoveChild(pChildItem);
   }
   pChildItem->m_pParent = this;
-  if (m_pFirstChild == NULL) {
+  if (!m_pFirstChild) {
     m_pFirstChild = pChildItem;
   } else {
     CXFA_LayoutItem* pExistingChildItem = m_pFirstChild;
     while (pExistingChildItem->m_pNextSibling) {
       pExistingChildItem = pExistingChildItem->m_pNextSibling;
     }
     pExistingChildItem->m_pNextSibling = pChildItem;
   }
 }
 void CXFA_LayoutItem::AddHeadChild(CXFA_LayoutItem* pChildItem) {
   if (pChildItem->m_pParent) {
     pChildItem->m_pParent->RemoveChild(pChildItem);
   }
   pChildItem->m_pParent = this;
-  if (m_pFirstChild == NULL) {
+  if (!m_pFirstChild) {
     m_pFirstChild = pChildItem;
   } else {
     CXFA_LayoutItem* pExistingChildItem = m_pFirstChild;
     m_pFirstChild = pChildItem;
     m_pFirstChild->m_pNextSibling = pExistingChildItem;
   }
 }
 void CXFA_LayoutItem::InsertChild(CXFA_LayoutItem* pBeforeItem,
                                   CXFA_LayoutItem* pChildItem) {
   if (pBeforeItem->m_pParent != this) {
     return;
   }
   if (pChildItem->m_pParent) {
-    pChildItem->m_pParent = NULL;
+    pChildItem->m_pParent = nullptr;
   }
   pChildItem->m_pParent = this;
   CXFA_LayoutItem* pExistingChildItem = pBeforeItem->m_pNextSibling;
   pBeforeItem->m_pNextSibling = pChildItem;
   pChildItem->m_pNextSibling = pExistingChildItem;
 }
 void CXFA_LayoutItem::RemoveChild(CXFA_LayoutItem* pChildItem) {
   if (pChildItem->m_pParent != this) {
     return;
   }
   if (m_pFirstChild == pChildItem) {
     m_pFirstChild = pChildItem->m_pNextSibling;
   } else {
     CXFA_LayoutItem* pExistingChildItem = m_pFirstChild;
     while (pExistingChildItem &&
            pExistingChildItem->m_pNextSibling != pChildItem) {
       pExistingChildItem = pExistingChildItem->m_pNextSibling;
     }
     if (pExistingChildItem) {
       pExistingChildItem->m_pNextSibling = pChildItem->m_pNextSibling;
     }
   }
-  pChildItem->m_pNextSibling = NULL;
-  pChildItem->m_pParent = NULL;
+  pChildItem->m_pNextSibling = nullptr;
+  pChildItem->m_pParent = nullptr;
 }
 CXFA_ContentLayoutItem* CXFA_ItemLayoutProcessor::ExtractLayoutItem() {
   CXFA_ContentLayoutItem* pLayoutItem = m_pLayoutItem;
   if (pLayoutItem) {
     m_pLayoutItem =
         static_cast<CXFA_ContentLayoutItem*>(pLayoutItem->m_pNextSibling);
     pLayoutItem->m_pNextSibling = nullptr;
   }
   if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Done ||
       !ToContentLayoutItem(m_pOldLayoutItem))
@@ skipping 66 matching lines @@
   CXFA_FFNotify* pNotify =
       pGenerateNode->GetDocument()->GetParser()->GetNotify();
   CXFA_LayoutProcessor* pDocLayout =
       pGenerateNode->GetDocument()->GetDocLayout();
   CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> sIterator(
       pGenerateNode);
   for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
        pNode = sIterator.MoveToNext()) {
     CXFA_ContentLayoutItem* pCurLayoutItem =
         (CXFA_ContentLayoutItem*)pNode->GetUserData(XFA_LAYOUTITEMKEY);
-    CXFA_ContentLayoutItem* pNextLayoutItem = NULL;
+    CXFA_ContentLayoutItem* pNextLayoutItem = nullptr;
     while (pCurLayoutItem) {
       pNextLayoutItem = pCurLayoutItem->m_pNext;
       pNotify->OnLayoutItemRemoving(pDocLayout, pCurLayoutItem);
       delete pCurLayoutItem;
       pCurLayoutItem = pNextLayoutItem;
     }
   }
   pGenerateNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pGenerateNode);
 }
 void CXFA_ItemLayoutProcessor::XFA_ItemLayoutProcessor_GotoNextContainerNode(
@@ skipping 144 matching lines @@
             case XFA_Element::Break:
               pCurActionNode = pBookendNode;
               nCurStage = XFA_ItemLayoutProcessorStages_BookendTrailer;
               return;
             default:
               break;
           }
         }
     }
     default:
-      pCurActionNode = NULL;
+      pCurActionNode = nullptr;
       nCurStage = XFA_ItemLayoutProcessorStages_Done;
   }
 }
 FX_BOOL CXFA_ItemLayoutProcessor::ProcessKeepNodesForCheckNext(
     CXFA_Node*& pCurActionNode,
     XFA_ItemLayoutProcessorStages& nCurStage,
     CXFA_Node*& pNextContainer,
     FX_BOOL& bLastKeepNode) {
   const bool bCanSplit = pNextContainer->GetIntact() == XFA_ATTRIBUTEENUM_None;
   FX_BOOL bNextKeep = FALSE;
   if (XFA_ExistContainerKeep(pNextContainer, FALSE)) {
     bNextKeep = TRUE;
   }
   if (bNextKeep && !bCanSplit) {
     if (!m_bIsProcessKeep && !m_bKeepBreakFinish) {
       m_pKeepHeadNode = pNextContainer;
       m_bIsProcessKeep = TRUE;
     }
   } else {
     if (m_bIsProcessKeep && m_pKeepHeadNode) {
       m_pKeepTailNode = pNextContainer;
       if (!m_bKeepBreakFinish &&
           XFA_ItemLayoutProcessor_FindBreakNode(
               pNextContainer->GetNodeItem(XFA_NODEITEM_FirstChild),
               pCurActionNode, nCurStage, TRUE)) {
         return TRUE;
       } else {
         pNextContainer = m_pKeepHeadNode;
         m_bKeepBreakFinish = TRUE;
-        m_pKeepHeadNode = NULL;
-        m_pKeepTailNode = NULL;
+        m_pKeepHeadNode = nullptr;
+        m_pKeepTailNode = nullptr;
         m_bIsProcessKeep = FALSE;
       }
     } else {
       if (m_bKeepBreakFinish) {
         bLastKeepNode = TRUE;
       }
       m_bKeepBreakFinish = FALSE;
     }
   }
   return FALSE;
 }
 FX_BOOL CXFA_ItemLayoutProcessor::ProcessKeepNodesForBreakBefore(
     CXFA_Node*& pCurActionNode,
     XFA_ItemLayoutProcessorStages& nCurStage,
     CXFA_Node* pContainerNode) {
   if (m_pKeepTailNode == pContainerNode) {
     pCurActionNode = m_pKeepHeadNode;
     m_bKeepBreakFinish = TRUE;
-    m_pKeepHeadNode = NULL;
-    m_pKeepTailNode = NULL;
+    m_pKeepHeadNode = nullptr;
+    m_pKeepTailNode = nullptr;
     m_bIsProcessKeep = FALSE;
     nCurStage = XFA_ItemLayoutProcessorStages_Container;
     return TRUE;
   }
   CXFA_Node* pBreakAfterNode =
       pContainerNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   if (XFA_ItemLayoutProcessor_FindBreakNode(pBreakAfterNode, pCurActionNode,
                                             nCurStage, FALSE)) {
     return TRUE;
   }
@@ skipping 156 matching lines @@
     CXFA_Node* pNode,
     CXFA_Node* pParentNode) {
   return FALSE;
 }
 void CXFA_ItemLayoutProcessor::DoLayoutPageArea(
     CXFA_ContainerLayoutItem* pPageAreaLayoutItem) {
   CXFA_Node* pFormNode = pPageAreaLayoutItem->m_pFormNode;
   CXFA_Node* pCurChildNode = XFA_LAYOUT_INVALIDNODE;
   XFA_ItemLayoutProcessorStages nCurChildNodeStage =
       XFA_ItemLayoutProcessorStages_None;
-  CXFA_LayoutItem* pBeforeItem = NULL;
+  CXFA_LayoutItem* pBeforeItem = nullptr;
   for (XFA_ItemLayoutProcessor_GotoNextContainerNode(
            pCurChildNode, nCurChildNodeStage, pFormNode, FALSE);
        pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
            pCurChildNode, nCurChildNodeStage, pFormNode, FALSE)) {
     if (nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
     }
     if (pCurChildNode->GetElementType() == XFA_Element::Variables) {
       continue;
     }
     CXFA_ItemLayoutProcessor* pProcessor =
-        new CXFA_ItemLayoutProcessor(pCurChildNode, NULL);
+        new CXFA_ItemLayoutProcessor(pCurChildNode, nullptr);
     pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
     if (!pProcessor->HasLayoutItem()) {
       delete pProcessor;
       continue;
     }
     FX_FLOAT fWidth, fHeight;
     pProcessor->GetCurrentComponentSize(fWidth, fHeight);
     FX_FLOAT fAbsoluteX = 0, fAbsoluteY = 0;
     CalculatePositionedContainerPos(pCurChildNode, fWidth, fHeight, fAbsoluteX,
                                     fAbsoluteY);
     pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
     CXFA_LayoutItem* pProcessItem = pProcessor->ExtractLayoutItem();
-    if (pBeforeItem == NULL) {
+    if (!pBeforeItem) {
       pPageAreaLayoutItem->AddHeadChild(pProcessItem);
     } else {
       pPageAreaLayoutItem->InsertChild(pBeforeItem, pProcessItem);
     }
     pBeforeItem = pProcessItem;
     delete pProcessor;
   }
-  pBeforeItem = NULL;
+  pBeforeItem = nullptr;
   CXFA_LayoutItem* pLayoutItem = pPageAreaLayoutItem->m_pFirstChild;
   while (pLayoutItem) {
     if (!pLayoutItem->IsContentLayoutItem() ||
         pLayoutItem->m_pFormNode->GetElementType() != XFA_Element::Draw) {
       pLayoutItem = pLayoutItem->m_pNextSibling;
       continue;
     }
     if (pLayoutItem->m_pFormNode->GetElementType() == XFA_Element::Draw) {
       CXFA_LayoutItem* pNextLayoutItem = pLayoutItem->m_pNextSibling;
       pPageAreaLayoutItem->RemoveChild(pLayoutItem);
-      if (pBeforeItem == NULL) {
+      if (!pBeforeItem) {
         pPageAreaLayoutItem->AddHeadChild(pLayoutItem);
       } else {
         pPageAreaLayoutItem->InsertChild(pBeforeItem, pLayoutItem);
       }
       pBeforeItem = pLayoutItem;
       pLayoutItem = pNextLayoutItem;
     }
   }
 }
 void CXFA_ItemLayoutProcessor::DoLayoutPositionedContainer(
@@ skipping 266 matching lines @@
   XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
       pLayoutRow->m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
       fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
       fContainerHeight);
   pLayoutRow->m_sSize = CFX_SizeF(fContainerWidth, fContainerHeight);
 }
 void CXFA_ItemLayoutProcessor::DoLayoutTableContainer(CXFA_Node* pLayoutNode) {
   if (m_pLayoutItem)
     return;
 
-  if (pLayoutNode == NULL) {
+  if (!pLayoutNode) {
     pLayoutNode = m_pFormNode;
   }
   ASSERT(m_pCurChildNode == XFA_LAYOUT_INVALIDNODE);
   m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
   FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
   FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
   XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
       m_pFormNode, fContainerWidth, fContainerHeight, bContainerWidthAutoSize,
       bContainerHeightAutoSize);
   FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
@@ skipping 24 matching lines @@
           CXFA_Measurement measure(wsWidth.AsStringC());
           m_rgSpecifiedColumnWidths.Add(measure.ToUnit(XFA_UNIT_Pt));
         }
       }
     }
   }
   int32_t iSpecifiedColumnCount = m_rgSpecifiedColumnWidths.GetSize();
   CXFA_LayoutContext layoutContext;
   layoutContext.m_prgSpecifiedColumnWidths = &m_rgSpecifiedColumnWidths;
   CXFA_LayoutContext* pLayoutContext =
-      iSpecifiedColumnCount > 0 ? &layoutContext : NULL;
+      iSpecifiedColumnCount > 0 ? &layoutContext : nullptr;
   if (m_pCurChildNode == XFA_LAYOUT_INVALIDNODE) {
     XFA_ItemLayoutProcessor_GotoNextContainerNode(
         m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE);
   }
   for (; m_pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
            m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE)) {
     layoutContext.m_bCurColumnWidthAvaiable = FALSE;
     layoutContext.m_fCurColumnWidth = 0;
     if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
@@ skipping 46 matching lines @@
       bMoreColumns = FALSE;
       FX_BOOL bAutoCol = FALSE;
       for (int32_t i = 0; i < iRowCount; i++) {
         while (rgRowItems[i] && (rgRowItemsSpan[i] <= 0 ||
                                  !XFA_ItemLayoutProcessor_IsTakingSpace(
                                      rgRowItems[i]->m_pFormNode))) {
           CXFA_ContentLayoutItem* pNewCell =
               (CXFA_ContentLayoutItem*)rgRowItems[i]->m_pNextSibling;
           if (rgRowItemsSpan[i] < 0 && XFA_ItemLayoutProcessor_IsTakingSpace(
                                            rgRowItems[i]->m_pFormNode)) {
-            pNewCell = NULL;
+            pNewCell = nullptr;
           }
           rgRowItems[i] = pNewCell;
           rgRowItemsSpan[i] =
               pNewCell
                   ? pNewCell->m_pFormNode->GetInteger(XFA_ATTRIBUTE_ColSpan)
                   : 0;
           rgRowItemsWidth[i] = pNewCell ? pNewCell->m_sSize.x : 0;
         }
         CXFA_ContentLayoutItem* pCell = rgRowItems[i];
         if (!pCell) {
@@ skipping 303 matching lines @@
     CXFA_ItemLayoutProcessor* pParentProcessor,
     CXFA_ItemLayoutProcessor* pChildProcessor,
     XFA_ItemLayoutProcessorResult eRetValue,
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*>& rgCurLineLayoutItem,
     FX_FLOAT& fContentCurRowAvailWidth,
     FX_FLOAT& fContentCurRowHeight,
     FX_FLOAT& fContentCurRowY,
     FX_BOOL& bAddedItemInRow,
     FX_BOOL& bForceEndPage,
     XFA_ItemLayoutProcessorResult& result) {
-  if (pParentProcessor == NULL || pChildProcessor == NULL) {
+  if (!pParentProcessor || !pChildProcessor) {
     return FALSE;
   }
   if (pParentProcessor->m_pCurChildNode->GetIntact() !=
           XFA_ATTRIBUTEENUM_None ||
       !pChildProcessor->m_bHasAvailHeight) {
     if (XFA_ExistContainerKeep(pParentProcessor->m_pCurChildNode, TRUE)) {
       FX_FLOAT fChildWidth, fChildHeight;
       pChildProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
       CFX_ArrayTemplate<CXFA_ContentLayoutItem*> keepLayoutItems;
       if (pParentProcessor->JudgePutNextPage(pParentProcessor->m_pLayoutItem,
@@ skipping 19 matching lines @@
       result = eRetValue;
       return TRUE;
     }
   }
   return FALSE;
 }
 FX_BOOL CXFA_ItemLayoutProcessor::JudgePutNextPage(
     CXFA_ContentLayoutItem* pParentLayoutItem,
     FX_FLOAT fChildHeight,
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*>& pKeepItems) {
-  if (pParentLayoutItem == NULL) {
+  if (!pParentLayoutItem) {
     return FALSE;
   }
   FX_FLOAT fItemsHeight = 0;
   for (CXFA_ContentLayoutItem* pChildLayoutItem =
            (CXFA_ContentLayoutItem*)pParentLayoutItem->m_pFirstChild;
        pChildLayoutItem;
        pChildLayoutItem =
            (CXFA_ContentLayoutItem*)pChildLayoutItem->m_pNextSibling) {
     if (XFA_ExistContainerKeep(pChildLayoutItem->m_pFormNode, FALSE)) {
       pKeepItems.Add(pChildLayoutItem);
@@ skipping 14 matching lines @@
     return;
   }
   CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> sIterator(
       pFormNode);
   for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode;
        pNode = sIterator.MoveToNext()) {
     if (pNode->IsContainerNode()) {
       CXFA_Node* pBindNode = pNode->GetBindData();
       if (pBindNode) {
         pBindNode->RemoveBindItem(pNode);
-        pNode->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
+        pNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
       }
     }
     pNode->SetFlag(XFA_NodeFlag_UnusedNode, true);
   }
 }
 void CXFA_ItemLayoutProcessor::ProcessUnUseOverFlow(
     CXFA_Node* pLeaderNode,
     CXFA_Node* pTrailerNode,
     CXFA_ContentLayoutItem* pTrailerItem,
     CXFA_Node* pFormNode) {
   ProcessUnUseBinds(pLeaderNode);
   ProcessUnUseBinds(pTrailerNode);
-  if (pFormNode == NULL) {
+  if (!pFormNode) {
     return;
   }
   if (pFormNode->GetElementType() == XFA_Element::Overflow ||
       pFormNode->GetElementType() == XFA_Element::Break) {
     pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
   }
   if (pLeaderNode && pFormNode) {
     pFormNode->RemoveChild(pLeaderNode);
   }
   if (pTrailerNode && pFormNode) {
@@ skipping 14 matching lines @@
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*> (&rgCurLineLayoutItems)[3],
     FX_BOOL bUseBreakControl,
     FX_FLOAT fAvailHeight,
     FX_FLOAT fRealHeight,
     FX_FLOAT& fContentCurRowY,
     FX_FLOAT& fContentWidthLimit,
     FX_FLOAT& fContentCurRowAvailWidth,
     FX_FLOAT& fContentCurRowHeight,
     FX_BOOL& bAddedItemInRow,
     FX_BOOL& bForceEndPage,
-    CXFA_LayoutContext* pLayoutContext = NULL,
+    CXFA_LayoutContext* pLayoutContext = nullptr,
     FX_BOOL bNewRow = FALSE) {
   FX_BOOL bTakeSpace =
       XFA_ItemLayoutProcessor_IsTakingSpace(pProcessor->m_pFormNode);
   uint8_t uHAlign = XFA_ItemLayoutProcessor_HAlignEnumToInt(
       pThis->m_pCurChildNode->GetEnum(XFA_ATTRIBUTE_HAlign));
   if (bContainerWidthAutoSize) {
     uHAlign = 0;
   }
   if ((eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb && uHAlign < uCurHAlignState) ||
       (eFlowStrategy == XFA_ATTRIBUTEENUM_Rl_tb && uHAlign > uCurHAlignState)) {
@@ skipping 46 matching lines @@
   FX_FLOAT fChildWidth, fChildHeight;
   pProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
   if (bUseRealHeight && fRealHeight < XFA_LAYOUT_FLOAT_PERCISION) {
     fRealHeight = XFA_LAYOUT_FLOAT_MAX;
     fAvailHeight = XFA_LAYOUT_FLOAT_MAX;
   }
   if (!bTakeSpace ||
       (fChildWidth <= fContentCurRowAvailWidth + XFA_LAYOUT_FLOAT_PERCISION) ||
       (fContentWidthLimit - fContentCurRowAvailWidth <=
        XFA_LAYOUT_FLOAT_PERCISION)) {
-    CXFA_Node *pOverflowLeaderNode = NULL, *pOverflowTrailerNode = NULL,
-              *pFormNode = NULL;
-    CXFA_ContentLayoutItem* pTrailerLayoutItem = NULL;
+    CXFA_Node* pOverflowLeaderNode = nullptr;
+    CXFA_Node* pOverflowTrailerNode = nullptr;
+    CXFA_Node* pFormNode = nullptr;
+    CXFA_ContentLayoutItem* pTrailerLayoutItem = nullptr;
     FX_BOOL bIsAddTrailerHeight = FALSE;
     if (pThis->m_pPageMgr &&
         pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
       pFormNode = pThis->m_pPageMgr->QueryOverflow(pProcessor->m_pFormNode);
-      if (pFormNode == NULL && pLayoutContext &&
+      if (!pFormNode && pLayoutContext &&
           pLayoutContext->m_pOverflowProcessor) {
         pFormNode = pLayoutContext->m_pOverflowNode;
         bUseInherited = TRUE;
       }
       if (pThis->m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
                                              pOverflowTrailerNode, FALSE,
                                              FALSE)) {
         if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowTrailerNode)) {
           if (pOverflowTrailerNode) {
             CXFA_ItemLayoutProcessor* pOverflowLeaderProcessor =
-                new CXFA_ItemLayoutProcessor(pOverflowTrailerNode, NULL);
+                new CXFA_ItemLayoutProcessor(pOverflowTrailerNode, nullptr);
             pOverflowLeaderProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
             pTrailerLayoutItem =
                 pOverflowLeaderProcessor->HasLayoutItem()
                     ? pOverflowLeaderProcessor->ExtractLayoutItem()
-                    : NULL;
+                    : nullptr;
             delete pOverflowLeaderProcessor;
           }
           if (bUseInherited) {
             bIsAddTrailerHeight =
                 pThis->IsAddNewRowForTrailer(pTrailerLayoutItem);
           } else {
             bIsAddTrailerHeight =
                 pProcessor->IsAddNewRowForTrailer(pTrailerLayoutItem);
           }
           if (bIsAddTrailerHeight) {
@@ skipping 97 matching lines @@
           rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
           bAddedItemInRow = TRUE;
           if (bTakeSpace) {
             fContentCurRowAvailWidth -= fChildWidth;
             if (fContentCurRowHeight < fChildHeight) {
               fContentCurRowHeight = fChildHeight;
             }
           }
           return XFA_ItemLayoutProcessorResult_PageFullBreak;
         }
-        CXFA_Node *pTempLeaderNode = NULL, *pTempTrailerNode = NULL;
+        CXFA_Node* pTempLeaderNode = nullptr;
+        CXFA_Node* pTempTrailerNode = nullptr;
         if (pThis->m_pPageMgr && !pProcessor->m_bUseInheriated &&
             eRetValue != XFA_ItemLayoutProcessorResult_PageFullBreak) {
           pThis->m_pPageMgr->ProcessOverflow(pFormNode, pTempLeaderNode,
                                              pTempTrailerNode, FALSE, TRUE);
         }
         if (pTrailerLayoutItem && bIsAddTrailerHeight) {
           XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
               pProcessor, fSplitPos, pTrailerLayoutItem, bUseInherited);
         } else {
           pProcessor->SplitLayoutItem(fSplitPos);
@@ skipping 26 matching lines @@
             fContentCurRowAvailWidth -= fChildWidth;
             if (fContentCurRowHeight < fChildHeight) {
               fContentCurRowHeight = fChildHeight;
             }
           }
         }
         return XFA_ItemLayoutProcessorResult_PageFullBreak;
       } else if (fContentCurRowY <= XFA_LAYOUT_FLOAT_PERCISION) {
         pProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
         if (pProcessor->m_pPageMgr->GetNextAvailContentHeight(fChildHeight)) {
-          CXFA_Node *pTempLeaderNode = NULL, *pTempTrailerNode = NULL;
+          CXFA_Node* pTempLeaderNode = nullptr;
+          CXFA_Node* pTempTrailerNode = nullptr;
           if (pThis->m_pPageMgr) {
-            if (pFormNode == NULL && pLayoutContext) {
+            if (!pFormNode && pLayoutContext) {
               pFormNode = pLayoutContext->m_pOverflowProcessor->m_pFormNode;
             }
             pThis->m_pPageMgr->ProcessOverflow(pFormNode, pTempLeaderNode,
                                                pTempTrailerNode, FALSE, TRUE);
           }
           if (bUseInherited) {
             pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                              pOverflowTrailerNode,
                                              pTrailerLayoutItem, pFormNode);
             pThis->m_bUseInheriated = TRUE;
@@ skipping 25 matching lines @@
           if (pTrailerLayoutItem) {
             XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(pProcessor, fSplitPos,
                                                           pTrailerLayoutItem);
           }
           if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
             XFA_ItemLayoutProcessor_AddPendingNode(pProcessor,
                                                    pOverflowLeaderNode, FALSE);
           }
         } else {
           if (eRetValue == XFA_ItemLayoutProcessorResult_Done) {
-            if (pFormNode == NULL && pLayoutContext) {
+            if (!pFormNode && pLayoutContext) {
               pFormNode = pLayoutContext->m_pOverflowProcessor->m_pFormNode;
             }
             if (pThis->m_pPageMgr) {
               pThis->m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
                                                  pOverflowTrailerNode, FALSE,
                                                  TRUE);
             }
             if (bUseInherited) {
               pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                                pOverflowTrailerNode,
@@ skipping 70 matching lines @@
   FX_FLOAT fContentWidthLimit =
       bContainerWidthAutoSize ? XFA_LAYOUT_FLOAT_MAX
                               : fContainerWidth - fLeftInset - fRightInset;
   FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
   FX_FLOAT fAvailHeight = fHeightLimit - fTopInset - fBottomInset;
   if (fAvailHeight < 0) {
     m_bHasAvailHeight = FALSE;
   }
   fRealHeight = fRealHeight - fTopInset - fBottomInset;
   FX_FLOAT fContentCurRowY = 0;
-  CXFA_ContentLayoutItem* pLayoutChild = NULL;
+  CXFA_ContentLayoutItem* pLayoutChild = nullptr;
   if (m_pLayoutItem) {
     if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Done &&
         eFlowStrategy != XFA_ATTRIBUTEENUM_Tb) {
       pLayoutChild = (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
       for (CXFA_ContentLayoutItem* pLayoutNext = pLayoutChild; pLayoutNext;
            pLayoutNext = (CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling) {
         if (pLayoutNext->m_sPos.y != pLayoutChild->m_sPos.y) {
           pLayoutChild = pLayoutNext;
         }
       }
@@ skipping 41 matching lines @@
   while (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Done) {
     FX_FLOAT fContentCurRowHeight = 0;
     FX_FLOAT fContentCurRowAvailWidth = fContentWidthLimit;
     m_fWidthLimite = fContentCurRowAvailWidth;
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*> rgCurLineLayoutItems[3];
     uint8_t uCurHAlignState =
         (eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb ? 0 : 2);
     if (pLayoutChild) {
       for (CXFA_ContentLayoutItem* pLayoutNext = pLayoutChild; pLayoutNext;
            pLayoutNext = (CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling) {
-        if (pLayoutNext->m_pNextSibling == NULL && m_pCurChildPreprocessor &&
+        if (!pLayoutNext->m_pNextSibling && m_pCurChildPreprocessor &&
             m_pCurChildPreprocessor->m_pFormNode == pLayoutNext->m_pFormNode) {
           pLayoutNext->m_pNext = m_pCurChildPreprocessor->m_pLayoutItem;
           m_pCurChildPreprocessor->m_pLayoutItem = pLayoutNext;
           break;
         }
         uint8_t uHAlign = XFA_ItemLayoutProcessor_HAlignEnumToInt(
             pLayoutNext->m_pFormNode->GetEnum(XFA_ATTRIBUTE_HAlign));
         rgCurLineLayoutItems[uHAlign].Add(pLayoutNext);
         if (eFlowStrategy == XFA_ATTRIBUTEENUM_Lr_tb) {
           if (uHAlign > uCurHAlignState) {
             uCurHAlignState = uHAlign;
           }
         } else if (uHAlign < uCurHAlignState) {
           uCurHAlignState = uHAlign;
         }
         if (XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutNext->m_pFormNode)) {
           if (pLayoutNext->m_sSize.y > fContentCurRowHeight) {
             fContentCurRowHeight = pLayoutNext->m_sSize.y;
           }
           fContentCurRowAvailWidth -= pLayoutNext->m_sSize.x;
         }
       }
       if ((CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild ==
           pLayoutChild) {
-        m_pLayoutItem->m_pFirstChild = NULL;
+        m_pLayoutItem->m_pFirstChild = nullptr;
       } else {
         CXFA_ContentLayoutItem* pLayoutNext =
             (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
         for (; pLayoutNext;
              pLayoutNext =
                  (CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling) {
           if ((CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling ==
               pLayoutChild) {
-            pLayoutNext->m_pNextSibling = NULL;
+            pLayoutNext->m_pNextSibling = nullptr;
             break;
           }
         }
       }
       CXFA_ContentLayoutItem* pLayoutNextTemp =
           (CXFA_ContentLayoutItem*)pLayoutChild;
       while (pLayoutNextTemp) {
-        pLayoutNextTemp->m_pParent = NULL;
+        pLayoutNextTemp->m_pParent = nullptr;
         CXFA_ContentLayoutItem* pSaveLayoutNext =
             (CXFA_ContentLayoutItem*)pLayoutNextTemp->m_pNextSibling;
-        pLayoutNextTemp->m_pNextSibling = NULL;
+        pLayoutNextTemp->m_pNextSibling = nullptr;
         pLayoutNextTemp = pSaveLayoutNext;
       }
-      pLayoutChild = NULL;
+      pLayoutChild = nullptr;
     }
     while (m_pCurChildNode) {
       CXFA_ItemLayoutProcessor* pProcessor = nullptr;
       FX_BOOL bAddedItemInRow = FALSE;
       fContentCurRowY +=
           XFA_ItemLayoutProcessor_InsertPendingItems(this, m_pFormNode);
       switch (m_nCurChildNodeStage) {
         case XFA_ItemLayoutProcessorStages_Keep:
         case XFA_ItemLayoutProcessorStages_None:
           break;
         case XFA_ItemLayoutProcessorStages_BreakBefore: {
           for (int32_t iIndex = 0; iIndex < m_arrayKeepItems.GetSize();
                iIndex++) {
             CXFA_ContentLayoutItem* pItem = m_arrayKeepItems.GetAt(iIndex);
             m_pLayoutItem->RemoveChild(pItem);
             fContentCalculatedHeight -= pItem->m_sSize.y;
           }
-          CXFA_Node *pLeaderNode = NULL, *pTrailerNode = NULL;
+          CXFA_Node* pLeaderNode = nullptr;
+          CXFA_Node* pTrailerNode = nullptr;
           FX_BOOL bCreatePage = FALSE;
           if (bUseBreakControl && m_pPageMgr &&
               m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, TRUE,
                                                     pLeaderNode, pTrailerNode,
                                                     bCreatePage) &&
               m_pFormNode->GetElementType() != XFA_Element::Form &&
               bCreatePage) {
             if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
               XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, TRUE);
             }
             if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
               if (m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent)
                           ->GetElementType() == XFA_Element::Form &&
-                  m_pLayoutItem == NULL) {
+                  !m_pLayoutItem) {
                 XFA_ItemLayoutProcessor_AddPendingNode(this, pTrailerNode,
                                                        TRUE);
               } else {
                 std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                     new CXFA_ItemLayoutProcessor(pTrailerNode, nullptr));
                 XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pTempProcessor.get(), bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, FALSE,
                     XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext);
               }
             }
             XFA_ItemLayoutProcessor_GotoNextContainerNode(
                 m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
             bForceEndPage = TRUE;
             bIsManualBreak = TRUE;
             goto SuspendAndCreateNewRow;
           }
         } break;
         case XFA_ItemLayoutProcessorStages_BreakAfter: {
-          CXFA_Node *pLeaderNode = NULL, *pTrailerNode = NULL;
+          CXFA_Node* pLeaderNode = nullptr;
+          CXFA_Node* pTrailerNode = nullptr;
           FX_BOOL bCreatePage = FALSE;
           if (bUseBreakControl && m_pPageMgr &&
               m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, FALSE,
                                                     pLeaderNode, pTrailerNode,
                                                     bCreatePage) &&
               m_pFormNode->GetElementType() != XFA_Element::Form) {
             if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
               std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                   new CXFA_ItemLayoutProcessor(pTrailerNode, nullptr));
               XFA_ItemLayoutProcessor_InsertFlowedItem(
@@ skipping 35 matching lines @@
               bForceEndPage = TRUE;
               bIsManualBreak = TRUE;
               if (m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Done) {
                 bBreakDone = TRUE;
               }
             }
             goto SuspendAndCreateNewRow;
           }
         } break;
         case XFA_ItemLayoutProcessorStages_BookendLeader: {
-          CXFA_Node* pLeaderNode = NULL;
+          CXFA_Node* pLeaderNode = nullptr;
           if (m_pCurChildPreprocessor) {
             pProcessor = m_pCurChildPreprocessor;
-            m_pCurChildPreprocessor = NULL;
+            m_pCurChildPreprocessor = nullptr;
           } else if (m_pPageMgr &&
                      m_pPageMgr->ProcessBookendLeaderOrTrailer(
                          m_pCurChildNode, TRUE, pLeaderNode)) {
             pProcessor = new CXFA_ItemLayoutProcessor(pLeaderNode, m_pPageMgr);
           }
           if (pProcessor) {
             if (XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pProcessor, bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
                     fAvailHeight, fRealHeight, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext) != XFA_ItemLayoutProcessorResult_Done) {
               goto SuspendAndCreateNewRow;
             } else {
               delete pProcessor;
-              pProcessor = NULL;
+              pProcessor = nullptr;
             }
           }
         } break;
         case XFA_ItemLayoutProcessorStages_BookendTrailer: {
-          CXFA_Node* pTrailerNode = NULL;
+          CXFA_Node* pTrailerNode = nullptr;
           if (m_pCurChildPreprocessor) {
             pProcessor = m_pCurChildPreprocessor;
-            m_pCurChildPreprocessor = NULL;
+            m_pCurChildPreprocessor = nullptr;
           } else if (m_pPageMgr &&
                      m_pPageMgr->ProcessBookendLeaderOrTrailer(
                          m_pCurChildNode, FALSE, pTrailerNode)) {
             pProcessor = new CXFA_ItemLayoutProcessor(pTrailerNode, m_pPageMgr);
           }
           if (pProcessor) {
             if (XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pProcessor, bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
                     fAvailHeight, fRealHeight, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext) != XFA_ItemLayoutProcessorResult_Done) {
               goto SuspendAndCreateNewRow;
             } else {
               delete pProcessor;
-              pProcessor = NULL;
+              pProcessor = nullptr;
             }
           }
         } break;
         case XFA_ItemLayoutProcessorStages_Container:
           ASSERT(m_pCurChildNode->IsContainerNode());
           if (m_pCurChildNode->GetElementType() == XFA_Element::Variables) {
             break;
           }
           if (fContentCurRowY >= fHeightLimit + XFA_LAYOUT_FLOAT_PERCISION &&
               XFA_ItemLayoutProcessor_IsTakingSpace(m_pCurChildNode)) {
             bForceEndPage = TRUE;
             goto SuspendAndCreateNewRow;
           }
           if (m_pCurChildNode->IsContainerNode()) {
             FX_BOOL bNewRow = FALSE;
             if (m_pCurChildPreprocessor) {
               pProcessor = m_pCurChildPreprocessor;
-              m_pCurChildPreprocessor = NULL;
+              m_pCurChildPreprocessor = nullptr;
               bNewRow = TRUE;
             } else {
               pProcessor =
                   new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
             }
             XFA_ItemLayoutProcessor_InsertPendingItems(pProcessor,
                                                        m_pCurChildNode);
             XFA_ItemLayoutProcessorResult rs =
                 XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pProcessor, bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
                     fAvailHeight, fRealHeight, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext, bNewRow);
             switch (rs) {
               case XFA_ItemLayoutProcessorResult_ManualBreak:
                 bIsManualBreak = TRUE;
               case XFA_ItemLayoutProcessorResult_PageFullBreak:
                 bForceEndPage = TRUE;
               case XFA_ItemLayoutProcessorResult_RowFullBreak:
                 goto SuspendAndCreateNewRow;
               case XFA_ItemLayoutProcessorResult_Done:
               default:
                 fContentCurRowY += XFA_ItemLayoutProcessor_InsertPendingItems(
                     pProcessor, m_pCurChildNode);
                 delete pProcessor;
-                pProcessor = NULL;
+                pProcessor = nullptr;
             }
           }
           break;
         case XFA_ItemLayoutProcessorStages_Done:
           break;
         default:
           break;
       }
       XFA_ItemLayoutProcessor_GotoNextContainerNode(
           m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
@@ skipping 23 matching lines @@
       m_PendingNodes.empty();
   if (bBreakDone) {
     bRetValue = FALSE;
   }
   XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
       m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
       fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
       fContainerHeight);
   if (fContainerHeight >= XFA_LAYOUT_FLOAT_PERCISION || m_pLayoutItem ||
       bRetValue) {
-    if (m_pLayoutItem == NULL) {
+    if (!m_pLayoutItem) {
       m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
     }
     if (fContainerHeight < 0) {
       fContainerHeight = 0;
     }
     SetCurrentComponentSize(fContainerWidth, fContainerHeight);
     if (bForceEndPage) {
       m_fUsedSize = 0;
     } else {
       m_fUsedSize += m_pLayoutItem->m_sSize.y;
@@ skipping 31 matching lines @@
   }
   if (!nTotalLength) {
     if (bContainerHeightAutoSize) {
       FX_FLOAT fNewHeight = fContentCurRowY;
       if (fContentCalculatedHeight > fNewHeight) {
         fContentCalculatedHeight = fNewHeight;
       }
     }
     return FALSE;
   }
-  if (m_pLayoutItem == NULL) {
+  if (!m_pLayoutItem) {
     m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
   }
   if (eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb) {
     FX_FLOAT fCurPos;
     fCurPos = 0;
     for (int32_t c = nGroupLengths[0], j = 0; j < c; j++) {
       if (bRootForceTb) {
         FX_FLOAT fAbsoluteX, fAbsoluteY;
         CalculatePositionedContainerPos(rgCurLineLayoutItems[0][j]->m_pFormNode,
                                         rgCurLineLayoutItems[0][j]->m_sSize.x,
@@ skipping 225 matching lines @@
   if (iMax < 0)
     return TRUE;
 
   int32_t iCount = m_PendingNodesCount[pTemplate];
   if (iCount >= iMax)
     return FALSE;
 
   m_PendingNodesCount[pTemplate] = iCount + 1;
   return TRUE;
 }