diff --git a/xfa/fxfa/layout/cxfa_itemlayoutprocessor.cpp b/xfa/fxfa/layout/cxfa_itemlayoutprocessor.cpp
index 4b7d287..dd5bf40 100644
--- a/xfa/fxfa/layout/cxfa_itemlayoutprocessor.cpp
+++ b/xfa/fxfa/layout/cxfa_itemlayoutprocessor.cpp
@@ -2463,8 +2463,11 @@
       pFormNode = pLayoutContext->m_pOverflowNode.Get();
       bUseInherited = true;
     }
-    if (m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                    pOverflowTrailerNode, false)) {
+    Optional<CXFA_LayoutPageMgr::OverflowData> overflow_data =
+        m_pPageMgr->ProcessOverflow(pFormNode, false);
+    if (overflow_data.has_value()) {
+      pOverflowLeaderNode = overflow_data.value().pLeader;
+      pOverflowTrailerNode = overflow_data.value().pTrailer;
       if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowTrailerNode)) {
         if (pOverflowTrailerNode) {
           auto pOverflowLeaderProcessor =
@@ -2495,14 +2498,14 @@
       (!bContainerHeightAutoSize &&
        m_fUsedSize + fAvailHeight + kXFALayoutPrecision >= fContainerHeight)) {
     if (!bTakeSpace || eRetValue == Result::kDone) {
-      if (pProcessor->m_bUseInheriated) {
+      if (pProcessor->m_bUseInherited) {
         if (pTrailerLayoutItem)
           pProcessor->AddTrailerBeforeSplit(childSize.height,
                                             pTrailerLayoutItem, false);
         if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode))
           pProcessor->AddPendingNode(pOverflowLeaderNode, false);
 
-        pProcessor->m_bUseInheriated = false;
+        pProcessor->m_bUseInherited = false;
       } else {
         if (bIsAddTrailerHeight)
           childSize.height -= pTrailerLayoutItem->m_sSize.height;
@@ -2531,7 +2534,7 @@
     }
 
     if (eRetValue == Result::kPageFullBreak) {
-      if (pProcessor->m_bUseInheriated) {
+      if (pProcessor->m_bUseInherited) {
         if (pTrailerLayoutItem) {
           pProcessor->AddTrailerBeforeSplit(childSize.height,
                                             pTrailerLayoutItem, false);
@@ -2539,7 +2542,7 @@
         if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode))
           pProcessor->AddPendingNode(pOverflowLeaderNode, false);
 
-        pProcessor->m_bUseInheriated = false;
+        pProcessor->m_bUseInherited = false;
       } else {
         if (bIsAddTrailerHeight)
           childSize.height -= pTrailerLayoutItem->m_sSize.height;
@@ -2583,12 +2586,9 @@
       return Result::kPageFullBreak;
     }
 
-    CXFA_Node* pTempLeaderNode = nullptr;
-    CXFA_Node* pTempTrailerNode = nullptr;
-    if (m_pPageMgr && !pProcessor->m_bUseInheriated &&
+    if (m_pPageMgr && !pProcessor->m_bUseInherited &&
         eRetValue != Result::kPageFullBreak) {
-      m_pPageMgr->ProcessOverflow(pFormNode, pTempLeaderNode, pTempTrailerNode,
-                                  true);
+      m_pPageMgr->ProcessOverflow(pFormNode, true);
     }
     if (pTrailerLayoutItem && bIsAddTrailerHeight) {
       pProcessor->AddTrailerBeforeSplit(fSplitPos, pTrailerLayoutItem,
@@ -2601,7 +2601,7 @@
       pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                        pOverflowTrailerNode, pTrailerLayoutItem,
                                        pFormNode);
-      m_bUseInheriated = true;
+      m_bUseInherited = true;
     } else {
       CXFA_LayoutItem* firstChild = pProcessor->m_pLayoutItem->GetFirstChild();
       if (firstChild && !firstChild->GetNextSibling() &&
@@ -2631,20 +2631,17 @@
   if (*fContentCurRowY <= kXFALayoutPrecision) {
     childSize = pProcessor->GetCurrentComponentSize();
     if (pProcessor->m_pPageMgr->GetNextAvailContentHeight(childSize.height)) {
-      CXFA_Node* pTempLeaderNode = nullptr;
-      CXFA_Node* pTempTrailerNode = nullptr;
       if (m_pPageMgr) {
         if (!pFormNode && pLayoutContext)
           pFormNode = pLayoutContext->m_pOverflowProcessor->GetFormNode();
 
-        m_pPageMgr->ProcessOverflow(pFormNode, pTempLeaderNode,
-                                    pTempTrailerNode, true);
+        m_pPageMgr->ProcessOverflow(pFormNode, true);
       }
       if (bUseInherited) {
         pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                          pOverflowTrailerNode,
                                          pTrailerLayoutItem, pFormNode);
-        m_bUseInheriated = true;
+        m_bUseInherited = true;
       }
       return Result::kPageFullBreak;
     }
@@ -2666,8 +2663,12 @@
   if (pProcessor->GetFormNode()->GetIntact() == XFA_AttributeValue::None &&
       eLayout == XFA_AttributeValue::Tb) {
     if (m_pPageMgr) {
-      m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                  pOverflowTrailerNode, true);
+      Optional<CXFA_LayoutPageMgr::OverflowData> overflow_data =
+          m_pPageMgr->ProcessOverflow(pFormNode, true);
+      if (overflow_data.has_value()) {
+        pOverflowLeaderNode = overflow_data.value().pLeader;
+        pOverflowTrailerNode = overflow_data.value().pTrailer;
+      }
     }
     if (pTrailerLayoutItem)
       pProcessor->AddTrailerBeforeSplit(fSplitPos, pTrailerLayoutItem, false);
@@ -2683,13 +2684,17 @@
   if (!pFormNode && pLayoutContext)
     pFormNode = pLayoutContext->m_pOverflowProcessor->GetFormNode();
   if (m_pPageMgr) {
-    m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                pOverflowTrailerNode, true);
+    Optional<CXFA_LayoutPageMgr::OverflowData> overflow_data =
+        m_pPageMgr->ProcessOverflow(pFormNode, true);
+    if (overflow_data.has_value()) {
+      pOverflowLeaderNode = overflow_data.value().pLeader;
+      pOverflowTrailerNode = overflow_data.value().pTrailer;
+    }
   }
   if (bUseInherited) {
     pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode, pOverflowTrailerNode,
                                      pTrailerLayoutItem, pFormNode);
-    m_bUseInheriated = true;
+    m_bUseInherited = true;
   }
   return Result::kPageFullBreak;
 }
diff --git a/xfa/fxfa/layout/cxfa_itemlayoutprocessor.h b/xfa/fxfa/layout/cxfa_itemlayoutprocessor.h
index eb32791..5cfd8a2 100644
--- a/xfa/fxfa/layout/cxfa_itemlayoutprocessor.h
+++ b/xfa/fxfa/layout/cxfa_itemlayoutprocessor.h
@@ -180,7 +180,7 @@
   Stage m_nCurChildNodeStage = Stage::kNone;
   Result m_ePreProcessRs = Result::kDone;
   bool m_bBreakPending = true;
-  bool m_bUseInheriated = false;
+  bool m_bUseInherited = false;
   bool m_bKeepBreakFinish = false;
   bool m_bIsProcessKeep = false;
   bool m_bHasAvailHeight = true;
diff --git a/xfa/fxfa/layout/cxfa_layoutpagemgr.cpp b/xfa/fxfa/layout/cxfa_layoutpagemgr.cpp
index df70266..53f276d 100644
--- a/xfa/fxfa/layout/cxfa_layoutpagemgr.cpp
+++ b/xfa/fxfa/layout/cxfa_layoutpagemgr.cpp
@@ -855,9 +855,7 @@
     if (!break_data.pLeader->IsContainerNode())
       return pdfium::nullopt;
 
-    if (!pDataScope)
-      pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
-
+    pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
     break_data.pLeader = pDocument->DataMerge_CopyContainer(
         break_data.pLeader, pFormNode, pDataScope, true, true, true);
     if (!break_data.pLeader)
@@ -915,10 +913,10 @@
   return pBookendAppendNode;
 }
 
-CXFA_Node* CXFA_LayoutPageMgr::BreakOverflow(CXFA_Node* pOverflowNode,
-                                             CXFA_Node*& pLeaderTemplate,
-                                             CXFA_Node*& pTrailerTemplate,
-                                             bool bCreatePage) {
+bool CXFA_LayoutPageMgr::BreakOverflow(const CXFA_Node* pOverflowNode,
+                                       bool bCreatePage,
+                                       CXFA_Node** pLeaderTemplate,
+                                       CXFA_Node** pTrailerTemplate) {
   CXFA_Node* pContainer =
       pOverflowNode->GetContainerParent()->GetTemplateNodeIfExists();
   if (pOverflowNode->GetElementType() == XFA_Element::Break) {
@@ -930,7 +928,7 @@
         pOverflowNode->JSObject()->GetCData(XFA_Attribute::OverflowTrailer);
     if (wsOverflowTarget.IsEmpty() && wsOverflowLeader.IsEmpty() &&
         wsOverflowTrailer.IsEmpty()) {
-      return nullptr;
+      return false;
     }
 
     if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) {
@@ -953,15 +951,15 @@
       }
     }
     if (!bCreatePage) {
-      pLeaderTemplate = ResolveBreakTarget(pContainer, true, wsOverflowLeader);
-      pTrailerTemplate =
+      *pLeaderTemplate = ResolveBreakTarget(pContainer, true, wsOverflowLeader);
+      *pTrailerTemplate =
           ResolveBreakTarget(pContainer, true, wsOverflowTrailer);
     }
-    return pOverflowNode;
+    return true;
   }
 
   if (pOverflowNode->GetElementType() != XFA_Element::Overflow)
-    return nullptr;
+    return false;
 
   WideString wsOverflowTarget =
       pOverflowNode->JSObject()->GetCData(XFA_Attribute::Target);
@@ -989,64 +987,62 @@
         pOverflowNode->JSObject()->GetCData(XFA_Attribute::Leader);
     WideString wsTrailer =
         pOverflowNode->JSObject()->GetCData(XFA_Attribute::Trailer);
-    pLeaderTemplate = ResolveBreakTarget(pContainer, true, wsLeader);
-    pTrailerTemplate = ResolveBreakTarget(pContainer, true, wsTrailer);
+    *pLeaderTemplate = ResolveBreakTarget(pContainer, true, wsLeader);
+    *pTrailerTemplate = ResolveBreakTarget(pContainer, true, wsTrailer);
   }
-  return pOverflowNode;
+  return true;
 }
 
-bool CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode,
-                                         CXFA_Node*& pLeaderNode,
-                                         CXFA_Node*& pTrailerNode,
-                                         bool bCreatePage) {
+Optional<CXFA_LayoutPageMgr::OverflowData> CXFA_LayoutPageMgr::ProcessOverflow(
+    CXFA_Node* pFormNode,
+    bool bCreatePage) {
   if (!pFormNode)
-    return false;
+    return pdfium::nullopt;
 
   CXFA_Node* pLeaderTemplate = nullptr;
   CXFA_Node* pTrailerTemplate = nullptr;
   bool bIsOverflowNode = pFormNode->GetElementType() == XFA_Element::Overflow ||
                          pFormNode->GetElementType() == XFA_Element::Break;
+  OverflowData overflow_data{nullptr, nullptr};
   for (CXFA_Node* pCurNode = bIsOverflowNode ? pFormNode
                                              : pFormNode->GetFirstChild();
        pCurNode; pCurNode = pCurNode->GetNextSibling()) {
-    if (BreakOverflow(pCurNode, pLeaderTemplate, pTrailerTemplate,
-                      bCreatePage)) {
+    if (BreakOverflow(pCurNode, bCreatePage, &pLeaderTemplate,
+                      &pTrailerTemplate)) {
       if (bIsOverflowNode)
         pFormNode = pCurNode->GetParent();
 
       CXFA_Document* pDocument = pCurNode->GetDocument();
       CXFA_Node* pDataScope = nullptr;
       if (pLeaderTemplate) {
-        if (!pDataScope)
-          pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
+        pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
 
-        pLeaderNode = pDocument->DataMerge_CopyContainer(
+        overflow_data.pLeader = pDocument->DataMerge_CopyContainer(
             pLeaderTemplate, pFormNode, pDataScope, true, true, true);
-        if (!pLeaderNode)
-          return false;
+        if (!overflow_data.pLeader)
+          return pdfium::nullopt;
 
-        pDocument->DataMerge_UpdateBindingRelations(pLeaderNode);
-        SetLayoutGeneratedNodeFlag(pLeaderNode);
+        pDocument->DataMerge_UpdateBindingRelations(overflow_data.pLeader);
+        SetLayoutGeneratedNodeFlag(overflow_data.pLeader);
       }
       if (pTrailerTemplate) {
         if (!pDataScope)
           pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
 
-        pTrailerNode = pDocument->DataMerge_CopyContainer(
+        overflow_data.pTrailer = pDocument->DataMerge_CopyContainer(
             pTrailerTemplate, pFormNode, pDataScope, true, true, true);
-        if (!pTrailerNode)
-          return false;
+        if (!overflow_data.pTrailer)
+          return pdfium::nullopt;
 
-        pDocument->DataMerge_UpdateBindingRelations(pTrailerNode);
-        SetLayoutGeneratedNodeFlag(pTrailerNode);
+        pDocument->DataMerge_UpdateBindingRelations(overflow_data.pTrailer);
+        SetLayoutGeneratedNodeFlag(overflow_data.pTrailer);
       }
-      return true;
+      return overflow_data;
     }
-    if (bIsOverflowNode) {
+    if (bIsOverflowNode)
       break;
-    }
   }
-  return false;
+  return pdfium::nullopt;
 }
 
 CXFA_Node* CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer(
diff --git a/xfa/fxfa/layout/cxfa_layoutpagemgr.h b/xfa/fxfa/layout/cxfa_layoutpagemgr.h
index 0006761..59f7df9 100644
--- a/xfa/fxfa/layout/cxfa_layoutpagemgr.h
+++ b/xfa/fxfa/layout/cxfa_layoutpagemgr.h
@@ -27,6 +27,11 @@
     bool bCreatePage;
   };
 
+  struct OverflowData {
+    CXFA_Node* pLeader;
+    CXFA_Node* pTrailer;
+  };
+
   explicit CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor);
   ~CXFA_LayoutPageMgr();
 
@@ -46,10 +51,8 @@
   }
   Optional<BreakData> ProcessBreakBefore(const CXFA_Node* pBreakNode);
   Optional<BreakData> ProcessBreakAfter(const CXFA_Node* pBreakNode);
-  bool ProcessOverflow(CXFA_Node* pFormNode,
-                       CXFA_Node*& pLeaderNode,
-                       CXFA_Node*& pTrailerNode,
-                       bool bCreatePage);
+  Optional<OverflowData> ProcessOverflow(CXFA_Node* pFormNode,
+                                         bool bCreatePage);
   CXFA_Node* QueryOverflow(CXFA_Node* pFormNode);
   CXFA_Node* ProcessBookendLeader(const CXFA_Node* pBookendNode);
   CXFA_Node* ProcessBookendTrailer(const CXFA_Node* pBookendNode);
@@ -77,10 +80,10 @@
                 XFA_AttributeValue eTargetType,
                 CXFA_Node* pTarget,
                 bool bStartNew);
-  CXFA_Node* BreakOverflow(CXFA_Node* pOverflowNode,
-                           CXFA_Node*& pLeaderTemplate,
-                           CXFA_Node*& pTrailerTemplate,
-                           bool bCreatePage);
+  bool BreakOverflow(const CXFA_Node* pOverflowNode,
+                     bool bCreatePage,
+                     CXFA_Node** pLeaderTemplate,
+                     CXFA_Node** pTrailerTemplate);
   CXFA_Node* ProcessBookendLeaderOrTrailer(const CXFA_Node* pBookendNode,
                                            bool bLeader);
   CXFA_Node* ResolveBookendLeaderOrTrailer(const CXFA_Node* pBookendNode,