Remove NULL in xfa/

xfa/fxfa/parser/xfa_layout_pagemgr_new.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_pagemgr_new.h"
 
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
@@ skipping 174 matching lines @@
 
 FX_BOOL CheckContentAreaNotUsed(
     CXFA_ContainerLayoutItem* pPageAreaLayoutItem,
     CXFA_Node* pContentArea,
     CXFA_ContainerLayoutItem*& pContentAreaLayoutItem) {
   for (CXFA_ContainerLayoutItem* pLayoutItem =
            (CXFA_ContainerLayoutItem*)pPageAreaLayoutItem->m_pFirstChild;
        pLayoutItem;
        pLayoutItem = (CXFA_ContainerLayoutItem*)pLayoutItem->m_pNextSibling) {
     if (pLayoutItem->m_pFormNode == pContentArea) {
-      if (pLayoutItem->m_pFirstChild == NULL) {
+      if (!pLayoutItem->m_pFirstChild) {
         pContentAreaLayoutItem = pLayoutItem;
         return TRUE;
       }
       return FALSE;
     }
   }
   return TRUE;
 }
 
 void SyncRemoveLayoutItem(CXFA_LayoutItem* pParentLayoutItem,
@@ skipping 21 matching lines @@
       m_pPageSetCurRoot(nullptr),
       m_pCurrentContainerRecord(nullptr),
       m_pCurPageArea(nullptr),
       m_nAvailPages(0),
       m_nCurPageCount(0),
       m_ePageSetMode(XFA_ATTRIBUTEENUM_OrderedOccurrence),
       m_bCreateOverFlowPage(FALSE) {}
 CXFA_LayoutPageMgr::~CXFA_LayoutPageMgr() {
   ClearData();
   CXFA_LayoutItem* pLayoutItem = GetRootLayoutItem();
-  CXFA_LayoutItem* pNextLayout = NULL;
+  CXFA_LayoutItem* pNextLayout = nullptr;
   for (; pLayoutItem; pLayoutItem = pNextLayout) {
     pNextLayout = pLayoutItem->m_pNextSibling;
     XFA_ReleaseLayoutItem(pLayoutItem);
   }
 }
 FX_BOOL CXFA_LayoutPageMgr::InitLayoutPage(CXFA_Node* pFormNode) {
   PrepareLayout();
   CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
   if (!pTemplateNode) {
     return FALSE;
   }
   m_pTemplatePageSetRoot = pTemplateNode->GetProperty(0, XFA_Element::PageSet);
   ASSERT(m_pTemplatePageSetRoot);
   if (m_pPageSetLayoutItemRoot) {
-    m_pPageSetLayoutItemRoot->m_pParent = NULL;
-    m_pPageSetLayoutItemRoot->m_pFirstChild = NULL;
-    m_pPageSetLayoutItemRoot->m_pNextSibling = NULL;
+    m_pPageSetLayoutItemRoot->m_pParent = nullptr;
+    m_pPageSetLayoutItemRoot->m_pFirstChild = nullptr;
+    m_pPageSetLayoutItemRoot->m_pNextSibling = nullptr;
     m_pPageSetLayoutItemRoot->m_pFormNode = m_pTemplatePageSetRoot;
   } else {
     m_pPageSetLayoutItemRoot =
         new CXFA_ContainerLayoutItem(m_pTemplatePageSetRoot);
   }
   m_pPageSetCurRoot = m_pPageSetLayoutItemRoot;
   m_pTemplatePageSetRoot->SetUserData(XFA_LAYOUTITEMKEY,
                                       (void*)m_pPageSetLayoutItemRoot);
   XFA_ATTRIBUTEENUM eRelation =
       m_pTemplatePageSetRoot->GetEnum(XFA_ATTRIBUTE_Relation);
   if (eRelation != XFA_ATTRIBUTEENUM_Unknown) {
     m_ePageSetMode = eRelation;
   }
   InitPageSetMap();
-  CXFA_Node* pPageArea = NULL;
+  CXFA_Node* pPageArea = nullptr;
   int32_t iCount = 0;
   for (pPageArea = m_pTemplatePageSetRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
        pPageArea;
        pPageArea = pPageArea->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pPageArea->GetElementType() == XFA_Element::PageArea) {
       iCount++;
       if (pPageArea->GetFirstChildByClass(XFA_Element::ContentArea)) {
         return TRUE;
       }
     }
   }
   if (iCount > 0) {
     return FALSE;
   }
   CXFA_Document* pDocument = pTemplateNode->GetDocument();
   CXFA_Document* pObjFactory = pDocument->GetParser()->GetFactory();
   pPageArea = m_pTemplatePageSetRoot->GetChild(0, XFA_Element::PageArea);
   if (!pPageArea) {
     pPageArea = pObjFactory->CreateNode(m_pTemplatePageSetRoot->GetPacketID(),
                                         XFA_Element::PageArea);
     if (!pPageArea) {
       return FALSE;
     }
-    m_pTemplatePageSetRoot->InsertChild(pPageArea, NULL);
+    m_pTemplatePageSetRoot->InsertChild(pPageArea, nullptr);
     pPageArea->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   CXFA_Node* pContentArea = pPageArea->GetChild(0, XFA_Element::ContentArea);
   if (!pContentArea) {
     pContentArea = pObjFactory->CreateNode(pPageArea->GetPacketID(),
                                            XFA_Element::ContentArea);
     if (!pContentArea) {
       return FALSE;
     }
-    pPageArea->InsertChild(pContentArea, NULL);
+    pPageArea->InsertChild(pContentArea, nullptr);
     pContentArea->SetFlag(XFA_NodeFlag_Initialized, true);
     pContentArea->SetMeasure(XFA_ATTRIBUTE_X,
                              CXFA_Measurement(0.25f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_Y,
                              CXFA_Measurement(0.25f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_W,
                              CXFA_Measurement(8.0f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_H,
                              CXFA_Measurement(10.5f, XFA_UNIT_In));
   }
   CXFA_Node* pMedium = pPageArea->GetChild(0, XFA_Element::Medium);
   if (!pMedium) {
     pMedium =
         pObjFactory->CreateNode(pPageArea->GetPacketID(), XFA_Element::Medium);
     if (!pContentArea) {
       return FALSE;
     }
-    pPageArea->InsertChild(pMedium, NULL);
+    pPageArea->InsertChild(pMedium, nullptr);
     pMedium->SetFlag(XFA_NodeFlag_Initialized, true);
     pMedium->SetMeasure(XFA_ATTRIBUTE_Short,
                         CXFA_Measurement(8.5f, XFA_UNIT_In));
     pMedium->SetMeasure(XFA_ATTRIBUTE_Long,
                         CXFA_Measurement(11.0f, XFA_UNIT_In));
   }
   return TRUE;
 }
 FX_BOOL CXFA_LayoutPageMgr::PrepareFirstPage(CXFA_Node* pRootSubform) {
   FX_BOOL bProBreakBefore = FALSE;
-  CXFA_Node* pBreakBeforeNode = NULL;
+  CXFA_Node* pBreakBeforeNode = nullptr;
   while (pRootSubform) {
     for (CXFA_Node* pBreakNode =
              pRootSubform->GetNodeItem(XFA_NODEITEM_FirstChild);
          pBreakNode;
          pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       XFA_Element eType = pBreakNode->GetElementType();
       if (eType == XFA_Element::BreakBefore ||
           (eType == XFA_Element::Break &&
            pBreakNode->GetEnum(XFA_ATTRIBUTE_Before) !=
                XFA_ATTRIBUTEENUM_Auto)) {
@@ skipping 19 matching lines @@
     m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition();
     return TRUE;
   }
   return AppendNewPage(TRUE);
 }
 FX_BOOL CXFA_LayoutPageMgr::AppendNewPage(FX_BOOL bFirstTemPage) {
   if (m_pCurrentContainerRecord !=
       m_rgProposedContainerRecord.GetTailPosition()) {
     return TRUE;
   }
-  CXFA_Node* pPageNode = GetNextAvailPageArea(NULL);
+  CXFA_Node* pPageNode = GetNextAvailPageArea(nullptr);
   if (!pPageNode) {
     return FALSE;
   }
-  if (bFirstTemPage && m_pCurrentContainerRecord == NULL) {
+  if (bFirstTemPage && !m_pCurrentContainerRecord) {
     m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition();
   }
   return !bFirstTemPage || m_pCurrentContainerRecord;
 }
 
 void CXFA_LayoutPageMgr::RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord,
                                             CXFA_ContainerRecord* pPrevRecord) {
   if (!pNewRecord || !pPrevRecord) {
     return;
   }
@@ skipping 70 matching lines @@
   }
   return pTestScript->GetDocument()->GetParser()->GetNotify()->RunScript(
       pTestScript, pTestScript->GetNodeItem(XFA_NODEITEM_Parent,
                                             XFA_ObjectType::ContainerNode));
 }
 CXFA_ContainerRecord* CXFA_LayoutPageMgr::CreateContainerRecord(
     CXFA_Node* pPageNode,
     FX_BOOL bCreateNew) {
   CXFA_ContainerRecord* pNewRecord = new CXFA_ContainerRecord();
   if (m_pCurrentContainerRecord) {
-    if (!IsPageSetRootOrderedOccurrence() || pPageNode == NULL) {
+    if (!IsPageSetRootOrderedOccurrence() || !pPageNode) {
       *pNewRecord = *GetCurrentContainerRecord();
       m_rgProposedContainerRecord.AddTail(pNewRecord);
       return pNewRecord;
     }
     CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent);
     if (!bCreateNew) {
       if (pPageSet == m_pTemplatePageSetRoot) {
         pNewRecord->pCurPageSet = m_pPageSetCurRoot;
       } else {
         CXFA_ContainerLayoutItem* pParentLayoutItem =
             (CXFA_ContainerLayoutItem*)pPageSet->GetUserData(XFA_LAYOUTITEMKEY);
-        if (pParentLayoutItem == NULL) {
+        if (!pParentLayoutItem) {
           pParentLayoutItem = m_pPageSetCurRoot;
         }
         pNewRecord->pCurPageSet = pParentLayoutItem;
       }
     } else {
-      CXFA_ContainerLayoutItem* pParentPageSetLayout = NULL;
+      CXFA_ContainerLayoutItem* pParentPageSetLayout = nullptr;
       if (pPageSet == GetCurrentContainerRecord()->pCurPageSet->m_pFormNode) {
         pParentPageSetLayout =
             (CXFA_ContainerLayoutItem*)GetCurrentContainerRecord()
                 ->pCurPageSet->m_pParent;
       } else {
         pParentPageSetLayout =
             (CXFA_ContainerLayoutItem*)pPageSet->GetNodeItem(
                                                    XFA_NODEITEM_Parent)
                 ->GetUserData(XFA_LAYOUTITEMKEY);
       }
       CXFA_ContainerLayoutItem* pPageSetLayoutItem =
           new CXFA_ContainerLayoutItem(pPageSet);
       pPageSet->SetUserData(XFA_LAYOUTITEMKEY, (void*)pPageSetLayoutItem);
-      if (pParentPageSetLayout == NULL) {
+      if (!pParentPageSetLayout) {
         CXFA_ContainerLayoutItem* pPrePageSet = m_pPageSetLayoutItemRoot;
         while (pPrePageSet->m_pNextSibling) {
           pPrePageSet = (CXFA_ContainerLayoutItem*)pPrePageSet->m_pNextSibling;
         }
         pPrePageSet->m_pNextSibling = pPageSetLayoutItem;
         m_pPageSetCurRoot = pPageSetLayoutItem;
       } else {
         pParentPageSetLayout->AddChild(pPageSetLayoutItem);
       }
       pNewRecord->pCurPageSet = pPageSetLayoutItem;
@@ skipping 12 matching lines @@
       }
     } else {
       pNewRecord->pCurPageSet = m_pPageSetLayoutItemRoot;
     }
   }
   m_rgProposedContainerRecord.AddTail(pNewRecord);
   return pNewRecord;
 }
 void CXFA_LayoutPageMgr::AddPageAreaLayoutItem(CXFA_ContainerRecord* pNewRecord,
                                                CXFA_Node* pNewPageArea) {
-  CXFA_ContainerLayoutItem* pNewPageAreaLayoutItem = NULL;
+  CXFA_ContainerLayoutItem* pNewPageAreaLayoutItem = nullptr;
   if (m_PageArray.GetSize() > m_nAvailPages) {
     CXFA_ContainerLayoutItem* pContainerItem = m_PageArray[m_nAvailPages];
     pContainerItem->m_pFormNode = pNewPageArea;
     m_nAvailPages++;
     pNewPageAreaLayoutItem = pContainerItem;
   } else {
     CXFA_FFNotify* pNotify =
         pNewPageArea->GetDocument()->GetParser()->GetNotify();
     CXFA_ContainerLayoutItem* pContainerItem =
         (CXFA_ContainerLayoutItem*)pNotify->OnCreateLayoutItem(pNewPageArea);
     m_PageArray.Add(pContainerItem);
     m_nAvailPages++;
     pNotify->OnPageEvent(pContainerItem, XFA_PAGEVIEWEVENT_PostRemoved);
     pNewPageAreaLayoutItem = pContainerItem;
   }
   pNewRecord->pCurPageSet->AddChild(pNewPageAreaLayoutItem);
   pNewRecord->pCurPageArea = pNewPageAreaLayoutItem;
-  pNewRecord->pCurContentArea = NULL;
+  pNewRecord->pCurContentArea = nullptr;
 }
 void CXFA_LayoutPageMgr::AddContentAreaLayoutItem(
     CXFA_ContainerRecord* pNewRecord,
     CXFA_Node* pContentArea) {
-  if (pContentArea == NULL) {
-    pNewRecord->pCurContentArea = NULL;
+  if (!pContentArea) {
+    pNewRecord->pCurContentArea = nullptr;
     return;
   }
   CXFA_ContainerLayoutItem* pNewContentAreaLayoutItem =
       new CXFA_ContainerLayoutItem(pContentArea);
   ASSERT(pNewRecord->pCurPageArea);
   pNewRecord->pCurPageArea->AddChild(pNewContentAreaLayoutItem);
   pNewRecord->pCurContentArea = pNewContentAreaLayoutItem;
 }
 
 void CXFA_LayoutPageMgr::FinishPaginatedPageSets() {
   CXFA_ContainerLayoutItem* pRootPageSetLayoutItem = m_pPageSetLayoutItemRoot;
   for (; pRootPageSetLayoutItem;
        pRootPageSetLayoutItem =
            (CXFA_ContainerLayoutItem*)pRootPageSetLayoutItem->m_pNextSibling) {
     CXFA_NodeIteratorTemplate<CXFA_ContainerLayoutItem,
                               PageSetContainerLayoutItem>
         sIterator(pRootPageSetLayoutItem);
     for (CXFA_ContainerLayoutItem* pPageSetLayoutItem = sIterator.GetCurrent();
          pPageSetLayoutItem; pPageSetLayoutItem = sIterator.MoveToNext()) {
       XFA_ATTRIBUTEENUM ePageRelation =
           pPageSetLayoutItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Relation);
       switch (ePageRelation) {
         case XFA_ATTRIBUTEENUM_OrderedOccurrence:
         default: { ProcessLastPageSet(); } break;
         case XFA_ATTRIBUTEENUM_SimplexPaginated:
         case XFA_ATTRIBUTEENUM_DuplexPaginated: {
-          CXFA_LayoutItem* pLastPageAreaLayoutItem = NULL;
+          CXFA_LayoutItem* pLastPageAreaLayoutItem = nullptr;
           int32_t nPageAreaCount = 0;
           for (CXFA_LayoutItem* pPageAreaLayoutItem =
                    pPageSetLayoutItem->m_pFirstChild;
                pPageAreaLayoutItem;
                pPageAreaLayoutItem = pPageAreaLayoutItem->m_pNextSibling) {
             if (pPageAreaLayoutItem->m_pFormNode->GetElementType() !=
                 XFA_Element::PageArea) {
               continue;
             }
             nPageAreaCount++;
             pLastPageAreaLayoutItem = pPageAreaLayoutItem;
           }
           if (!pLastPageAreaLayoutItem) {
             break;
           }
           if (!FindPageAreaFromPageSet_SimplexDuplex(
-                  pPageSetLayoutItem->m_pFormNode, NULL, NULL, NULL, TRUE, TRUE,
-                  nPageAreaCount == 1 ? XFA_ATTRIBUTEENUM_Only
-                                      : XFA_ATTRIBUTEENUM_Last) &&
+                  pPageSetLayoutItem->m_pFormNode, nullptr, nullptr, nullptr,
+                  TRUE, TRUE, nPageAreaCount == 1 ? XFA_ATTRIBUTEENUM_Only
+                                                  : XFA_ATTRIBUTEENUM_Last) &&
               (nPageAreaCount == 1 &&
                !FindPageAreaFromPageSet_SimplexDuplex(
-                   pPageSetLayoutItem->m_pFormNode, NULL, NULL, NULL, TRUE,
-                   TRUE, XFA_ATTRIBUTEENUM_Last))) {
+                   pPageSetLayoutItem->m_pFormNode, nullptr, nullptr, nullptr,
+                   TRUE, TRUE, XFA_ATTRIBUTEENUM_Last))) {
             break;
           }
           CXFA_Node* pNode = m_pCurPageArea;
           XFA_ATTRIBUTEENUM eCurChoice =
               pNode->GetEnum(XFA_ATTRIBUTE_PagePosition);
           if (eCurChoice == XFA_ATTRIBUTEENUM_Last) {
             XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any;
             pNode->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven);
             XFA_ATTRIBUTEENUM eLastChoice =
                 pLastPageAreaLayoutItem->m_pFormNode->GetEnum(
@@ skipping 95 matching lines @@
   return m_PageArray.Find(const_cast<CXFA_ContainerLayoutItem*>(pPage));
 }
 FX_BOOL CXFA_LayoutPageMgr::RunBreak(XFA_Element eBreakType,
                                      XFA_ATTRIBUTEENUM eTargetType,
                                      CXFA_Node* pTarget,
                                      FX_BOOL bStartNew) {
   FX_BOOL bRet = FALSE;
   switch (eTargetType) {
     case XFA_ATTRIBUTEENUM_ContentArea:
       if (pTarget && pTarget->GetElementType() != XFA_Element::ContentArea) {
-        pTarget = NULL;
+        pTarget = nullptr;
       }
       if (!pTarget || !m_pCurrentContainerRecord ||
           pTarget !=
               GetCurrentContainerRecord()->pCurContentArea->m_pFormNode ||
           bStartNew) {
-        CXFA_Node* pPageArea = NULL;
+        CXFA_Node* pPageArea = nullptr;
         if (pTarget) {
           pPageArea = pTarget->GetNodeItem(XFA_NODEITEM_Parent);
         }
         pPageArea = GetNextAvailPageArea(pPageArea, pTarget);
-        bRet = pPageArea != NULL;
+        bRet = !!pPageArea;
       }
       break;
     case XFA_ATTRIBUTEENUM_PageArea:
       if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) {
-        pTarget = NULL;
+        pTarget = nullptr;
       }
       if (!pTarget || !m_pCurrentContainerRecord ||
           pTarget != GetCurrentContainerRecord()->pCurPageArea->m_pFormNode ||
           bStartNew) {
-        CXFA_Node* pPageArea = GetNextAvailPageArea(pTarget, NULL, TRUE);
-        bRet = pPageArea != NULL;
+        CXFA_Node* pPageArea = GetNextAvailPageArea(pTarget, nullptr, TRUE);
+        bRet = !!pPageArea;
       }
       break;
     case XFA_ATTRIBUTEENUM_PageOdd:
       if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) {
-        pTarget = NULL;
+        pTarget = nullptr;
       }
       break;
     case XFA_ATTRIBUTEENUM_PageEven:
       if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea) {
-        pTarget = NULL;
+        pTarget = nullptr;
       }
       break;
     case XFA_ATTRIBUTEENUM_Auto:
     default:
       break;
   }
   return bRet;
 }
 FX_BOOL CXFA_LayoutPageMgr::ExecuteBreakBeforeOrAfter(
     CXFA_Node* pCurNode,
@@ skipping 65 matching lines @@
   }
   return FALSE;
 }
 
 FX_BOOL CXFA_LayoutPageMgr::ProcessBreakBeforeOrAfter(
     CXFA_Node* pBreakNode,
     FX_BOOL bBefore,
     CXFA_Node*& pBreakLeaderNode,
     CXFA_Node*& pBreakTrailerNode,
     FX_BOOL& bCreatePage) {
-  CXFA_Node *pLeaderTemplate = NULL, *pTrailerTemplate = NULL;
+  CXFA_Node* pLeaderTemplate = nullptr;
+  CXFA_Node* pTrailerTemplate = nullptr;
   CXFA_Node* pFormNode = pBreakNode->GetNodeItem(XFA_NODEITEM_Parent,
                                                  XFA_ObjectType::ContainerNode);
   if (XFA_ItemLayoutProcessor_IsTakingSpace(pFormNode)) {
     bCreatePage = ExecuteBreakBeforeOrAfter(pBreakNode, bBefore,
                                             pLeaderTemplate, pTrailerTemplate);
     CXFA_Document* pDocument = pBreakNode->GetDocument();
-    CXFA_Node* pDataScope = NULL;
+    CXFA_Node* pDataScope = nullptr;
     pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent,
                                        XFA_ObjectType::ContainerNode);
     if (pLeaderTemplate) {
       if (!pDataScope) {
         pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
       }
       pBreakLeaderNode = pDocument->DataMerge_CopyContainer(
           pLeaderTemplate, pFormNode, pDataScope, TRUE);
       pDocument->DataMerge_UpdateBindingRelations(pBreakLeaderNode);
       SetLayoutGeneratedNodeFlag(pBreakLeaderNode);
     }
     if (pTrailerTemplate) {
       if (!pDataScope) {
         pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
       }
       pBreakTrailerNode = pDocument->DataMerge_CopyContainer(
           pTrailerTemplate, pFormNode, pDataScope, TRUE);
       pDocument->DataMerge_UpdateBindingRelations(pBreakTrailerNode);
       SetLayoutGeneratedNodeFlag(pBreakTrailerNode);
     }
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CXFA_LayoutPageMgr::ProcessBookendLeaderOrTrailer(
     CXFA_Node* pBookendNode,
     FX_BOOL bLeader,
     CXFA_Node*& pBookendAppendNode) {
-  CXFA_Node* pLeaderTemplate = NULL;
+  CXFA_Node* pLeaderTemplate = nullptr;
   CXFA_Node* pFormNode = pBookendNode->GetNodeItem(
       XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
   if (ResolveBookendLeaderOrTrailer(pBookendNode, bLeader, pLeaderTemplate)) {
     CXFA_Document* pDocument = pBookendNode->GetDocument();
-    CXFA_Node* pDataScope = NULL;
+    CXFA_Node* pDataScope = nullptr;
     if (pLeaderTemplate) {
       if (!pDataScope) {
         pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
       }
       pBookendAppendNode = pDocument->DataMerge_CopyContainer(
           pLeaderTemplate, pFormNode, pDataScope, TRUE);
       pDocument->DataMerge_UpdateBindingRelations(pBookendAppendNode);
       SetLayoutGeneratedNodeFlag(pBookendAppendNode);
       return TRUE;
     }
@@ skipping 38 matching lines @@
         }
       }
       if (!bCreatePage) {
         pLeaderTemplate =
             ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
         pTrailerTemplate =
             ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
       }
       return pOverflowNode;
     }
-    return NULL;
-  } else if (pOverflowNode->GetElementType() == XFA_Element::Overflow) {
-    CFX_WideStringC wsOverflowLeader;
-    CFX_WideStringC wsOverflowTrailer;
-    CFX_WideStringC wsOverflowTarget;
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_Leader, wsOverflowLeader);
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_Trailer, wsOverflowTrailer);
-    pOverflowNode->TryCData(XFA_ATTRIBUTE_Target, wsOverflowTarget);
-    if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) {
-      CXFA_Node* pTarget =
-          ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget);
-      if (pTarget) {
-        m_bCreateOverFlowPage = TRUE;
-        switch (pTarget->GetElementType()) {
-          case XFA_Element::PageArea:
-            RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget,
-                     TRUE);
-            break;
-          case XFA_Element::ContentArea:
-            RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea,
-                     pTarget, TRUE);
-            break;
-          default:
-            break;
-        }
+    return nullptr;
+  }
+
+  if (pOverflowNode->GetElementType() != XFA_Element::Overflow)
+    return nullptr;
+
+  CFX_WideStringC wsOverflowLeader;
+  CFX_WideStringC wsOverflowTrailer;
+  CFX_WideStringC wsOverflowTarget;
+  pOverflowNode->TryCData(XFA_ATTRIBUTE_Leader, wsOverflowLeader);
+  pOverflowNode->TryCData(XFA_ATTRIBUTE_Trailer, wsOverflowTrailer);
+  pOverflowNode->TryCData(XFA_ATTRIBUTE_Target, wsOverflowTarget);
+  if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) {
+    CXFA_Node* pTarget =
+        ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget);
+    if (pTarget) {
+      m_bCreateOverFlowPage = TRUE;
+      switch (pTarget->GetElementType()) {
+        case XFA_Element::PageArea:
+          RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget,
+                   TRUE);
+          break;
+        case XFA_Element::ContentArea:
+          RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea,
+                   pTarget, TRUE);
+          break;
+        default:
+          break;
       }
     }
-    if (!bCreatePage) {
-      pLeaderTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
-      pTrailerTemplate =
-          ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
-    }
-    return pOverflowNode;
   }
-  return nullptr;
+  if (!bCreatePage) {
+    pLeaderTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
+    pTrailerTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
+  }
+  return pOverflowNode;
 }
 
 FX_BOOL CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode,
                                             CXFA_Node*& pLeaderNode,
                                             CXFA_Node*& pTrailerNode,
                                             FX_BOOL bDataMerge,
                                             FX_BOOL bCreatePage) {
-  if (pFormNode == NULL) {
+  if (!pFormNode) {
     return FALSE;
   }
-  CXFA_Node *pLeaderTemplate = NULL, *pTrailerTemplate = NULL;
+  CXFA_Node* pLeaderTemplate = nullptr;
+  CXFA_Node* pTrailerTemplate = nullptr;
   FX_BOOL bIsOverflowNode = FALSE;
   if (pFormNode->GetElementType() == XFA_Element::Overflow ||
       pFormNode->GetElementType() == XFA_Element::Break) {
     bIsOverflowNode = TRUE;
   }
   for (CXFA_Node* pCurNode =
            bIsOverflowNode ? pFormNode
                            : pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) {
     if (BreakOverflow(pCurNode, pLeaderTemplate, pTrailerTemplate,
                       bCreatePage)) {
       if (bIsOverflowNode) {
         pFormNode = pCurNode->GetNodeItem(XFA_NODEITEM_Parent);
       }
       CXFA_Document* pDocument = pCurNode->GetDocument();
-      CXFA_Node* pDataScope = NULL;
+      CXFA_Node* pDataScope = nullptr;
       if (pLeaderTemplate) {
         if (!pDataScope) {
           pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
         }
         pLeaderNode = pDocument->DataMerge_CopyContainer(
             pLeaderTemplate, pFormNode, pDataScope, TRUE);
         pDocument->DataMerge_UpdateBindingRelations(pLeaderNode);
         SetLayoutGeneratedNodeFlag(pLeaderNode);
       }
       if (pTrailerTemplate) {
@@ skipping 42 matching lines @@
   }
   return FALSE;
 }
 FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet(
     CXFA_Node* pPageSet,
     CXFA_Node* pStartChild,
     CXFA_Node* pTargetPageArea,
     CXFA_Node* pTargetContentArea,
     FX_BOOL bNewPage,
     FX_BOOL bQuery) {
-  if (pPageSet == NULL && pStartChild == NULL) {
+  if (!pPageSet && !pStartChild) {
     return FALSE;
   }
   if (IsPageSetRootOrderedOccurrence()) {
     return FindPageAreaFromPageSet_Ordered(pPageSet, pStartChild,
                                            pTargetPageArea, pTargetContentArea,
                                            bNewPage, bQuery);
   }
   XFA_ATTRIBUTEENUM ePreferredPosition = m_pCurrentContainerRecord
                                              ? XFA_ATTRIBUTEENUM_Rest
                                              : XFA_ATTRIBUTEENUM_First;
@@ skipping 20 matching lines @@
       return FALSE;
     }
   }
   FX_BOOL bRes = FALSE;
   CXFA_Node* pCurrentNode =
       pStartChild ? pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling)
                   : pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pCurrentNode->GetElementType() == XFA_Element::PageArea) {
-      if ((pTargetPageArea == pCurrentNode || pTargetPageArea == NULL)) {
-        if (pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea) ==
-            NULL) {
+      if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) {
+        if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) {
           if (pTargetPageArea == pCurrentNode) {
             CreateMinPageRecord(pCurrentNode, TRUE);
-            pTargetPageArea = NULL;
+            pTargetPageArea = nullptr;
           }
           continue;
         }
         if (!bQuery) {
           CXFA_ContainerRecord* pNewRecord =
-              CreateContainerRecord(pCurrentNode, pStartChild == NULL);
+              CreateContainerRecord(pCurrentNode, !pStartChild);
           AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
-          if (pTargetContentArea == NULL) {
+          if (!pTargetContentArea) {
             pTargetContentArea =
                 pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea);
           }
           AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
         }
         m_pCurPageArea = pCurrentNode;
         m_nCurPageCount = 1;
         bRes = TRUE;
         break;
       }
       if (!bQuery) {
         CreateMinPageRecord(pCurrentNode, FALSE);
       }
     } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) {
-      if (FindPageAreaFromPageSet_Ordered(pCurrentNode, NULL, pTargetPageArea,
-                                          pTargetContentArea, bNewPage,
-                                          bQuery)) {
+      if (FindPageAreaFromPageSet_Ordered(pCurrentNode, nullptr,
+                                          pTargetPageArea, pTargetContentArea,
+                                          bNewPage, bQuery)) {
         bRes = TRUE;
         break;
       }
       if (!bQuery) {
         CreateMinPageSetRecord(pCurrentNode, TRUE);
       }
     }
   }
   if (!pStartChild && bRes && !bQuery) {
     m_pPageSetMap.SetAt(pPageSet, ++iPageSetCount);
   }
   return bRes;
 }
 FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_SimplexDuplex(
     CXFA_Node* pPageSet,
     CXFA_Node* pStartChild,
     CXFA_Node* pTargetPageArea,
     CXFA_Node* pTargetContentArea,
     FX_BOOL bNewPage,
     FX_BOOL bQuery,
     XFA_ATTRIBUTEENUM ePreferredPosition) {
   const XFA_ATTRIBUTEENUM eFallbackPosition = XFA_ATTRIBUTEENUM_Any;
-  CXFA_Node *pPreferredPageArea = NULL, *pFallbackPageArea = NULL;
-  CXFA_Node* pCurrentNode = NULL;
+  CXFA_Node* pPreferredPageArea = nullptr;
+  CXFA_Node* pFallbackPageArea = nullptr;
+  CXFA_Node* pCurrentNode = nullptr;
   if (!pStartChild || pStartChild->GetElementType() == XFA_Element::PageArea) {
     pCurrentNode = pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
   } else {
     pCurrentNode = pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling);
   }
   for (; pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pCurrentNode->GetElementType() == XFA_Element::PageArea) {
       if (!MatchPageAreaOddOrEven(pCurrentNode, FALSE)) {
         continue;
@@ skipping 21 matching lines @@
           continue;
         }
         if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated ||
             pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) ==
                 XFA_ATTRIBUTEENUM_Any) {
           pPreferredPageArea = pCurrentNode;
           break;
         }
         return FALSE;
       }
-      if ((pTargetPageArea == pCurrentNode || pTargetPageArea == NULL)) {
-        if (pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea) ==
-            NULL) {
+      if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) {
+        if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) {
           if (pTargetPageArea == pCurrentNode) {
             CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
             AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
-            pTargetPageArea = NULL;
+            pTargetPageArea = nullptr;
           }
           continue;
         }
         if ((ePreferredPosition == XFA_ATTRIBUTEENUM_Rest &&
              eCurPagePosition == XFA_ATTRIBUTEENUM_Any) ||
             eCurPagePosition == ePreferredPosition) {
           pPreferredPageArea = pCurrentNode;
           break;
         } else if (eCurPagePosition == eFallbackPosition &&
                    !pFallbackPageArea) {
           pFallbackPageArea = pCurrentNode;
         }
       } else if (pTargetPageArea &&
                  !MatchPageAreaOddOrEven(pTargetPageArea, FALSE)) {
         CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
         AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
         AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass(
                                                  XFA_Element::ContentArea));
       }
     } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) {
       if (FindPageAreaFromPageSet_SimplexDuplex(
-              pCurrentNode, NULL, pTargetPageArea, pTargetContentArea, bNewPage,
-              bQuery, ePreferredPosition)) {
+              pCurrentNode, nullptr, pTargetPageArea, pTargetContentArea,
+              bNewPage, bQuery, ePreferredPosition)) {
         break;
       }
     }
   }
-  CXFA_Node* pCurPageArea = NULL;
+  CXFA_Node* pCurPageArea = nullptr;
   if (pPreferredPageArea) {
     pCurPageArea = pPreferredPageArea;
   } else if (pFallbackPageArea) {
     pCurPageArea = pFallbackPageArea;
   }
   if (!pCurPageArea) {
     return FALSE;
   }
   if (!bQuery) {
     CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
     AddPageAreaLayoutItem(pNewRecord, pCurPageArea);
-    if (pTargetContentArea == NULL) {
+    if (!pTargetContentArea) {
       pTargetContentArea =
           pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
     }
     AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
   }
   m_pCurPageArea = pCurPageArea;
   return TRUE;
 }
 FX_BOOL CXFA_LayoutPageMgr::MatchPageAreaOddOrEven(CXFA_Node* pPageArea,
                                                    FX_BOOL bLastMatch) {
@@ skipping 11 matching lines @@
     return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 0
                                                : iPageCount % 2 == 1;
   }
   return TRUE;
 }
 CXFA_Node* CXFA_LayoutPageMgr::GetNextAvailPageArea(
     CXFA_Node* pTargetPageArea,
     CXFA_Node* pTargetContentArea,
     FX_BOOL bNewPage,
     FX_BOOL bQuery) {
-  if (m_pCurPageArea == NULL) {
-    FindPageAreaFromPageSet(m_pTemplatePageSetRoot, NULL, pTargetPageArea,
+  if (!m_pCurPageArea) {
+    FindPageAreaFromPageSet(m_pTemplatePageSetRoot, nullptr, pTargetPageArea,
                             pTargetContentArea, bNewPage, bQuery);
     ASSERT(m_pCurPageArea);
     return m_pCurPageArea;
   }
-  if (pTargetPageArea == NULL || pTargetPageArea == m_pCurPageArea) {
+  if (!pTargetPageArea || pTargetPageArea == m_pCurPageArea) {
     if (!bNewPage && GetNextContentArea(pTargetContentArea)) {
       return m_pCurPageArea;
     }
     if (IsPageSetRootOrderedOccurrence()) {
       int32_t iMax = -1;
       CXFA_Node* pOccurNode =
           m_pCurPageArea->GetFirstChildByClass(XFA_Element::Occur);
       if (pOccurNode) {
         pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
       }
       if ((iMax < 0 || m_nCurPageCount < iMax)) {
         if (!bQuery) {
           CXFA_ContainerRecord* pNewRecord =
               CreateContainerRecord(m_pCurPageArea);
           AddPageAreaLayoutItem(pNewRecord, m_pCurPageArea);
-          if (pTargetContentArea == NULL) {
+          if (!pTargetContentArea) {
             pTargetContentArea =
                 m_pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
           }
           AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
         }
         m_nCurPageCount++;
         return m_pCurPageArea;
       }
     }
   }
   if (!bQuery && IsPageSetRootOrderedOccurrence()) {
     CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE);
   }
   if (FindPageAreaFromPageSet(m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent),
                               m_pCurPageArea, pTargetPageArea,
                               pTargetContentArea, bNewPage, bQuery)) {
     return m_pCurPageArea;
   }
   CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent);
   while (TRUE) {
-    if (FindPageAreaFromPageSet(pPageSet, NULL, pTargetPageArea,
+    if (FindPageAreaFromPageSet(pPageSet, nullptr, pTargetPageArea,
                                 pTargetContentArea, bNewPage, bQuery)) {
       return m_pCurPageArea;
     }
     if (!bQuery && IsPageSetRootOrderedOccurrence()) {
       CreateMinPageSetRecord(pPageSet);
     }
-    if (FindPageAreaFromPageSet(NULL, pPageSet, pTargetPageArea,
+    if (FindPageAreaFromPageSet(nullptr, pPageSet, pTargetPageArea,
                                 pTargetContentArea, bNewPage, bQuery)) {
       return m_pCurPageArea;
     }
     if (pPageSet == m_pTemplatePageSetRoot) {
       break;
     }
     pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent);
   }
-  return NULL;
+  return nullptr;
 }
 
 FX_BOOL CXFA_LayoutPageMgr::GetNextContentArea(CXFA_Node* pContentArea) {
   CXFA_Node* pCurContentNode =
       GetCurrentContainerRecord()->pCurContentArea->m_pFormNode;
-  if (pContentArea == NULL) {
+  if (!pContentArea) {
     pContentArea =
         pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea);
-    if (pContentArea == NULL) {
+    if (!pContentArea) {
       return FALSE;
     }
   } else {
     if (pContentArea->GetNodeItem(XFA_NODEITEM_Parent) != m_pCurPageArea) {
       return FALSE;
     }
-    CXFA_ContainerLayoutItem* pContentAreaLayout = NULL;
+    CXFA_ContainerLayoutItem* pContentAreaLayout = nullptr;
     if (!CheckContentAreaNotUsed(GetCurrentContainerRecord()->pCurPageArea,
                                  pContentArea, pContentAreaLayout)) {
       return FALSE;
     }
     if (pContentAreaLayout) {
       if (pContentAreaLayout->m_pFormNode != pCurContentNode) {
         CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
         pNewRecord->pCurContentArea = pContentAreaLayout;
         return TRUE;
       } else {
@@ skipping 17 matching lines @@
           pPageSetNode->GetEnum(XFA_ATTRIBUTE_Relation);
       if (eRelation == XFA_ATTRIBUTEENUM_OrderedOccurrence) {
         m_pPageSetMap.SetAt(pPageSetNode, 0);
       }
     }
   }
 }
 int32_t CXFA_LayoutPageMgr::CreateMinPageRecord(CXFA_Node* pPageArea,
                                                 FX_BOOL bTargetPageArea,
                                                 FX_BOOL bCreateLast) {
-  if (pPageArea == NULL) {
+  if (!pPageArea) {
     return 0;
   }
   CXFA_Node* pOccurNode = pPageArea->GetFirstChildByClass(XFA_Element::Occur);
   int32_t iMin = 0;
   if ((pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) ||
       bTargetPageArea) {
     CXFA_Node* pContentArea =
         pPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
     if (iMin < 1 && bTargetPageArea && !pContentArea) {
       iMin = 1;
     }
     int32_t i = 0;
     if (bCreateLast) {
       i = m_nCurPageCount;
     }
     for (; i < iMin; i++) {
       CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
       AddPageAreaLayoutItem(pNewRecord, pPageArea);
       AddContentAreaLayoutItem(pNewRecord, pContentArea);
     }
   }
   return iMin;
 }
 void CXFA_LayoutPageMgr::CreateMinPageSetRecord(CXFA_Node* pPageSet,
                                                 FX_BOOL bCreateAll) {
-  if (pPageSet == NULL) {
+  if (!pPageSet) {
     return;
   }
   int32_t iCurSetCount = 0;
   if (!m_pPageSetMap.Lookup(pPageSet, iCurSetCount)) {
     return;
   }
   if (bCreateAll) {
     iCurSetCount = 0;
   }
   CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur);
@@ skipping 11 matching lines @@
                      XFA_Element::PageSet) {
             CreateMinPageSetRecord(pCurrentPageNode, TRUE);
           }
         }
       }
       m_pPageSetMap.SetAt(pPageSet, iMin);
     }
   }
 }
 void CXFA_LayoutPageMgr::CreateNextMinRecord(CXFA_Node* pRecordNode) {
-  if (pRecordNode == NULL) {
+  if (!pRecordNode) {
     return;
   }
   for (CXFA_Node* pCurrentNode =
            pRecordNode->GetNodeItem(XFA_NODEITEM_NextSibling);
        pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pCurrentNode->GetElementType() == XFA_Element::PageArea) {
       CreateMinPageRecord(pCurrentNode, FALSE);
     } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) {
       CreateMinPageSetRecord(pCurrentNode, TRUE);
     }
   }
 }
 void CXFA_LayoutPageMgr::ProcessLastPageSet() {
   CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE);
   CreateNextMinRecord(m_pCurPageArea);
   CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent);
   while (TRUE) {
     CreateMinPageSetRecord(pPageSet);
     if (pPageSet == m_pTemplatePageSetRoot) {
       break;
     }
     CreateNextMinRecord(pPageSet);
     pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent);
   }
 }
 FX_BOOL CXFA_LayoutPageMgr::GetNextAvailContentHeight(FX_FLOAT fChildHeight) {
   CXFA_Node* pCurContentNode =
       GetCurrentContainerRecord()->pCurContentArea->m_pFormNode;
-  if (pCurContentNode == NULL) {
+  if (!pCurContentNode) {
     return FALSE;
   }
   pCurContentNode =
       pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea);
   if (pCurContentNode) {
     FX_FLOAT fNextContentHeight =
         pCurContentNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
     return fNextContentHeight > fChildHeight;
   }
   CXFA_Node* pPageNode = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode;
   CXFA_Node* pOccurNode = pPageNode->GetFirstChildByClass(XFA_Element::Occur);
   int32_t iMax = 0;
   if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE)) {
     if (m_nCurPageCount == iMax) {
       CXFA_Node* pSrcPage = m_pCurPageArea;
       int32_t nSrcPageCount = m_nCurPageCount;
       FX_POSITION psSrcRecord = m_rgProposedContainerRecord.GetTailPosition();
-      CXFA_Node* pNextPage = GetNextAvailPageArea(NULL, NULL, FALSE, TRUE);
+      CXFA_Node* pNextPage =
+          GetNextAvailPageArea(nullptr, nullptr, FALSE, TRUE);
       m_pCurPageArea = pSrcPage;
       m_nCurPageCount = nSrcPageCount;
       CXFA_ContainerRecord* pPrevRecord =
           (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(
               psSrcRecord);
       while (psSrcRecord) {
         FX_POSITION psSaveRecord = psSrcRecord;
         CXFA_ContainerRecord* pInsertRecord =
             (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(
                 psSrcRecord);
@@ skipping 37 matching lines @@
   if (m_rgProposedContainerRecord.GetCount() > 0) {
     FX_POSITION sPos;
     sPos = m_rgProposedContainerRecord.GetHeadPosition();
     while (sPos) {
       CXFA_ContainerRecord* pRecord =
           (CXFA_ContainerRecord*)m_rgProposedContainerRecord.GetNext(sPos);
       delete pRecord;
     }
     m_rgProposedContainerRecord.RemoveAll();
   }
-  m_pCurrentContainerRecord = NULL;
-  m_pCurPageArea = NULL;
+  m_pCurrentContainerRecord = nullptr;
+  m_pCurPageArea = nullptr;
   m_nCurPageCount = 0;
   m_bCreateOverFlowPage = FALSE;
   m_pPageSetMap.RemoveAll();
 }
 CXFA_LayoutItem* CXFA_LayoutPageMgr::FindOrCreateLayoutItem(
     CXFA_Node* pFormNode) {
   return pFormNode->GetDocument()->GetParser()->GetNotify()->OnCreateLayoutItem(
       pFormNode);
 }
 
@@ skipping 21 matching lines @@
             sIterator(pCurLayoutItem->m_pFormNode);
         for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
              pNode = sIterator.MoveToNext()) {
           pNode->SetFlag(XFA_NodeFlag_UnusedNode, false);
         }
       }
     }
     if (pCurLayoutItem->m_pFirstChild) {
       SaveLayoutItem(pCurLayoutItem);
     }
-    pCurLayoutItem->m_pParent = NULL;
-    pCurLayoutItem->m_pNextSibling = NULL;
-    pCurLayoutItem->m_pFirstChild = NULL;
+    pCurLayoutItem->m_pParent = nullptr;
+    pCurLayoutItem->m_pNextSibling = nullptr;
+    pCurLayoutItem->m_pFirstChild = nullptr;
     if (!pCurLayoutItem->IsContentLayoutItem() &&
         pCurLayoutItem->m_pFormNode->GetElementType() !=
             XFA_Element::PageArea) {
       delete pCurLayoutItem;
     }
     pCurLayoutItem = pNextLayoutItem;
   }
 }
 CXFA_Node* CXFA_LayoutPageMgr::QueryOverflow(
     CXFA_Node* pFormNode,
     CXFA_LayoutContext* pLayoutContext) {
   for (CXFA_Node* pCurNode = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) {
     if (pCurNode->GetElementType() == XFA_Element::Break) {
       CFX_WideStringC wsOverflowLeader;
       CFX_WideStringC wsOverflowTarget;
       CFX_WideStringC wsOverflowTrailer;
       pCurNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader);
       pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer);
       pCurNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget);
       if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() ||
           !wsOverflowTarget.IsEmpty()) {
         return pCurNode;
       }
-      return NULL;
+      return nullptr;
     } else if (pCurNode->GetElementType() == XFA_Element::Overflow) {
       return pCurNode;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 void CXFA_LayoutPageMgr::MergePageSetContents() {
   CXFA_Document* pDocument = m_pTemplatePageSetRoot->GetDocument();
   CXFA_FFNotify* pNotify = pDocument->GetParser()->GetNotify();
   CXFA_LayoutProcessor* pDocLayout = pDocument->GetDocLayout();
   CXFA_ContainerLayoutItem* pRootLayout = GetRootLayoutItem();
   {
     for (int32_t iIndex = 0; iIndex < pDocument->m_pPendingPageSet.GetSize();
          iIndex++) {
       CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
           sIterator(pDocument->m_pPendingPageSet.GetAt(iIndex));
       for (CXFA_Node* pNode = sIterator.GetCurrent(); 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);
       }
     }
   }
   int32_t iIndex = 0;
   for (; pRootLayout;
        pRootLayout = (CXFA_ContainerLayoutItem*)pRootLayout->m_pNextSibling) {
     CXFA_Node* pPendingPageSet = nullptr;
@@ skipping 13 matching lines @@
           XFA_XDPPACKET_Template) {
         pPendingPageSet =
             pRootPageSetContainerItem->m_pFormNode->CloneTemplateToForm(FALSE);
       } else {
         pPendingPageSet = pRootPageSetContainerItem->m_pFormNode;
       }
     }
     if (pRootPageSetContainerItem->m_pFormNode->GetUserData(
             XFA_LAYOUTITEMKEY) == pRootPageSetContainerItem) {
       pRootPageSetContainerItem->m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY,
-                                                          NULL);
+                                                          nullptr);
     }
     pRootPageSetContainerItem->m_pFormNode = pPendingPageSet;
     pPendingPageSet->ClearFlag(XFA_NodeFlag_UnusedNode);
     for (CXFA_ContainerLayoutItem* pContainerItem = iterator.MoveToNext();
          pContainerItem; pContainerItem = iterator.MoveToNext()) {
       CXFA_Node* pNode = pContainerItem->m_pFormNode;
       if (pNode->GetPacketID() != XFA_XDPPACKET_Template) {
         continue;
       }
       switch (pNode->GetElementType()) {
         case XFA_Element::PageSet: {
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
           pContainerItem->m_pFormNode = XFA_NodeMerge_CloneOrMergeContainer(
               pDocument, pParentNode, pContainerItem->m_pFormNode, TRUE);
         } break;
         case XFA_Element::PageArea: {
           CXFA_ContainerLayoutItem* pFormLayout = pContainerItem;
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
           FX_BOOL bIsExistForm = TRUE;
           for (int32_t iLevel = 0; iLevel < 3; iLevel++) {
             pFormLayout = (CXFA_ContainerLayoutItem*)pFormLayout->m_pFirstChild;
             if (iLevel == 2) {
               while (pFormLayout &&
                      !XFA_ItemLayoutProcessor_IsTakingSpace(
                          pFormLayout->m_pFormNode)) {
                 pFormLayout =
                     (CXFA_ContainerLayoutItem*)pFormLayout->m_pNextSibling;
               }
             }
-            if (pFormLayout == NULL) {
+            if (!pFormLayout) {
               bIsExistForm = FALSE;
               break;
             }
           }
           if (bIsExistForm) {
             CXFA_Node* pNewSubform = pFormLayout->m_pFormNode;
             if (pContainerItem->m_pOldSubform &&
                 pContainerItem->m_pOldSubform != pNewSubform) {
               CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance(
                   pDocument, pContainerItem->m_pFormNode->GetElementType(),
@@ skipping 171 matching lines @@
     m_PageArray.RemoveAt(i);
     pNotify->OnPageEvent(pPage, XFA_PAGEVIEWEVENT_PostRemoved);
     delete pPage;
   }
   ClearRecordList();
 }
 void XFA_ReleaseLayoutItem_NoPageArea(CXFA_LayoutItem* pLayoutItem) {
   CXFA_LayoutItem *pNext, *pNode = pLayoutItem->m_pFirstChild;
   while (pNode) {
     pNext = pNode->m_pNextSibling;
-    pNode->m_pParent = NULL;
+    pNode->m_pParent = nullptr;
     XFA_ReleaseLayoutItem_NoPageArea(pNode);
     pNode = pNext;
   }
   if (pLayoutItem->m_pFormNode->GetElementType() != XFA_Element::PageArea) {
     delete pLayoutItem;
   }
 }
 void CXFA_LayoutPageMgr::PrepareLayout() {
-  m_pPageSetCurRoot = NULL;
+  m_pPageSetCurRoot = nullptr;
   m_ePageSetMode = XFA_ATTRIBUTEENUM_OrderedOccurrence;
   m_nAvailPages = 0;
   ClearRecordList();
   if (!m_pPageSetLayoutItemRoot) {
     return;
   }
   CXFA_ContainerLayoutItem* pRootLayoutItem = m_pPageSetLayoutItemRoot;
   if (pRootLayoutItem &&
       pRootLayoutItem->m_pFormNode->GetPacketID() == XFA_XDPPACKET_Form) {
     CXFA_Node* pPageSetFormNode = pRootLayoutItem->m_pFormNode;
     pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.RemoveAll();
     if (pPageSetFormNode->HasRemovedChildren()) {
       XFA_ReleaseLayoutItem(pRootLayoutItem);
-      m_pPageSetLayoutItemRoot = NULL;
-      pRootLayoutItem = NULL;
-      pPageSetFormNode = NULL;
+      m_pPageSetLayoutItemRoot = nullptr;
+      pRootLayoutItem = nullptr;
+      pPageSetFormNode = nullptr;
       m_PageArray.RemoveAll();
     }
     while (pPageSetFormNode) {
       CXFA_Node* pNextPageSet =
           pPageSetFormNode->GetNextSameClassSibling(XFA_Element::PageSet);
       pPageSetFormNode->GetNodeItem(XFA_NODEITEM_Parent)
           ->RemoveChild(pPageSetFormNode, FALSE);
       pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.Add(
           pPageSetFormNode);
       pPageSetFormNode = pNextPageSet;
     }
   }
   pRootLayoutItem = m_pPageSetLayoutItemRoot;
-  CXFA_ContainerLayoutItem* pNextLayout = NULL;
+  CXFA_ContainerLayoutItem* pNextLayout = nullptr;
   for (; pRootLayoutItem; pRootLayoutItem = pNextLayout) {
     pNextLayout = (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling;
     SaveLayoutItem(pRootLayoutItem);
     delete pRootLayoutItem;
   }
-  m_pPageSetLayoutItemRoot = NULL;
+  m_pPageSetLayoutItemRoot = nullptr;
 }