Split the XFA_OBJECTTYPE enum into two parts.

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 161 matching lines @@
               XFA_RESOLVENODE_Parent);
       if (iCount > 0 && rs.nodes[0]->IsNode())
         return rs.nodes[0]->AsNode();
     }
     iSpliteIndex = iSpliteNextIndex;
   }
   return nullptr;
 }
 
 void SetLayoutGeneratedNodeFlag(CXFA_Node* pNode) {
-  pNode->SetFlag(XFA_NODEFLAG_LayoutGeneratedNode, false);
-  pNode->ClearFlag(XFA_NODEFLAG_UnusedNode);
+  pNode->SetFlag(XFA_NodeFlag_LayoutGeneratedNode, false);
+  pNode->ClearFlag(XFA_NodeFlag_UnusedNode);
 }
 
 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) {
@@ skipping 90 matching lines @@
   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);
-    pPageArea->SetFlag(XFA_NODEFLAG_Initialized, true);
+    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);
-    pContentArea->SetFlag(XFA_NODEFLAG_Initialized, true);
+    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);
-    pMedium->SetFlag(XFA_NODEFLAG_Initialized, true);
+    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;
@@ skipping 116 matching lines @@
 }
 
 FX_BOOL XFA_LayoutPageMgr_RunBreakTestScript(CXFA_Node* pTestScript) {
   CFX_WideString wsExpression;
   pTestScript->TryContent(wsExpression);
   if (wsExpression.IsEmpty()) {
     return TRUE;
   }
   return pTestScript->GetDocument()->GetParser()->GetNotify()->RunScript(
       pTestScript, pTestScript->GetNodeItem(XFA_NODEITEM_Parent,
-                                            XFA_OBJECTTYPE_ContainerNode));
+                                            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) {
       *pNewRecord = *GetCurrentContainerRecord();
       m_rgProposedContainerRecord.AddTail(pNewRecord);
       return pNewRecord;
@@ skipping 291 matching lines @@
     CXFA_Node* pCurNode,
     FX_BOOL bBefore,
     CXFA_Node*& pBreakLeaderTemplate,
     CXFA_Node*& pBreakTrailerTemplate) {
   XFA_ELEMENT eType = pCurNode->GetClassID();
   switch (eType) {
     case XFA_ELEMENT_BreakBefore:
     case XFA_ELEMENT_BreakAfter: {
       CFX_WideStringC wsBreakLeader, wsBreakTrailer;
       CXFA_Node* pFormNode = pCurNode->GetNodeItem(
-          XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);
+          XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
       CXFA_Node* pContainer = pFormNode->GetTemplateNode();
       FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
       CXFA_Node* pScript = pCurNode->GetFirstChildByClass(XFA_ELEMENT_Script);
       if (pScript && !XFA_LayoutPageMgr_RunBreakTestScript(pScript)) {
         return FALSE;
       }
       CFX_WideStringC wsTarget = pCurNode->GetCData(XFA_ATTRIBUTE_Target);
       CXFA_Node* pTarget =
           ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget);
       wsBreakTrailer = pCurNode->GetCData(XFA_ATTRIBUTE_Trailer);
       wsBreakLeader = pCurNode->GetCData(XFA_ATTRIBUTE_Leader);
       pBreakLeaderTemplate =
           ResolveBreakTarget(pContainer, TRUE, wsBreakLeader);
       pBreakTrailerTemplate =
           ResolveBreakTarget(pContainer, TRUE, wsBreakTrailer);
       if (RunBreak(eType, pCurNode->GetEnum(XFA_ATTRIBUTE_TargetType), pTarget,
                    bStartNew)) {
         return TRUE;
       } else {
         if (m_rgProposedContainerRecord.GetCount() > 0 &&
             m_pCurrentContainerRecord ==
                 m_rgProposedContainerRecord.GetHeadPosition() &&
             eType == XFA_ELEMENT_BreakBefore) {
           CXFA_Node* pParentNode = pFormNode->GetNodeItem(
-              XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);
+              XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
           if (!pParentNode ||
               pFormNode !=
                   pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild,
-                                           XFA_OBJECTTYPE_ContainerNode)) {
+                                           XFA_ObjectType::ContainerNode)) {
             break;
           }
           pParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
           if (!pParentNode || pParentNode->GetClassID() != XFA_ELEMENT_Form) {
             break;
           }
           return TRUE;
         }
       }
     } break;
@@ skipping 17 matching lines @@
 }
 
 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* pFormNode = pBreakNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                                 XFA_OBJECTTYPE_ContainerNode);
+                                                 XFA_ObjectType::ContainerNode);
   if (XFA_ItemLayoutProcessor_IsTakingSpace(pFormNode)) {
     bCreatePage = ExecuteBreakBeforeOrAfter(pBreakNode, bBefore,
                                             pLeaderTemplate, pTrailerTemplate);
     CXFA_Document* pDocument = pBreakNode->GetDocument();
     CXFA_Node* pDataScope = NULL;
     pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                       XFA_OBJECTTYPE_ContainerNode);
+                                       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* pFormNode = pBookendNode->GetNodeItem(
-      XFA_NODEITEM_Parent, XFA_OBJECTTYPE_ContainerNode);
+      XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
   if (ResolveBookendLeaderOrTrailer(pBookendNode, bLeader, pLeaderTemplate)) {
     CXFA_Document* pDocument = pBookendNode->GetDocument();
     CXFA_Node* pDataScope = NULL;
     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;
     }
   }
   return FALSE;
 }
 CXFA_Node* CXFA_LayoutPageMgr::BreakOverflow(CXFA_Node* pOverflowNode,
                                              CXFA_Node*& pLeaderTemplate,
                                              CXFA_Node*& pTrailerTemplate,
                                              FX_BOOL bCreatePage) {
   CXFA_Node* pContainer =
-      pOverflowNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                 XFA_OBJECTTYPE_ContainerNode)
+      pOverflowNode
+          ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode)
           ->GetTemplateNode();
   if (pOverflowNode->GetClassID() == XFA_ELEMENT_Break) {
     CFX_WideStringC wsOverflowLeader;
     CFX_WideStringC wsOverflowTarget;
     CFX_WideStringC wsOverflowTrailer;
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader);
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer);
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget);
     if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() ||
         !wsOverflowTarget.IsEmpty()) {
@@ skipping 112 matching lines @@
     }
   }
   return FALSE;
 }
 FX_BOOL CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer(
     CXFA_Node* pBookendNode,
     FX_BOOL bLeader,
     CXFA_Node*& pBookendAppendTemplate) {
   CFX_WideStringC wsBookendLeader;
   CXFA_Node* pContainer =
-      pBookendNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                XFA_OBJECTTYPE_ContainerNode)
+      pBookendNode
+          ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode)
           ->GetTemplateNode();
   if (pBookendNode->GetClassID() == XFA_ELEMENT_Break) {
     pBookendNode->TryCData(
         bLeader ? XFA_ATTRIBUTE_BookendLeader : XFA_ATTRIBUTE_BookendTrailer,
         wsBookendLeader);
     if (!wsBookendLeader.IsEmpty()) {
       pBookendAppendTemplate =
           ResolveBreakTarget(pContainer, FALSE, wsBookendLeader);
       return TRUE;
     }
@@ skipping 517 matching lines @@
   return pFormNode->GetDocument()->GetParser()->GetNotify()->OnCreateLayoutItem(
       pFormNode);
 }
 
 void CXFA_LayoutPageMgr::SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem) {
   CXFA_LayoutItem* pNextLayoutItem;
   CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild;
   while (pCurLayoutItem) {
     pNextLayoutItem = pCurLayoutItem->m_pNextSibling;
     if (pCurLayoutItem->IsContentLayoutItem()) {
-      uint32_t dwFlag = pCurLayoutItem->m_pFormNode->GetFlag();
-      if (dwFlag & (XFA_NODEFLAG_HasRemoved)) {
+      if (pCurLayoutItem->m_pFormNode->HasRemovedChildren()) {
         CXFA_FFNotify* pNotify =
             m_pTemplatePageSetRoot->GetDocument()->GetParser()->GetNotify();
         CXFA_LayoutProcessor* pDocLayout =
             m_pTemplatePageSetRoot->GetDocument()->GetDocLayout();
         if (pCurLayoutItem->m_pFirstChild) {
           SyncRemoveLayoutItem(pCurLayoutItem, pNotify, pDocLayout);
         }
         pNotify->OnLayoutItemRemoving(pDocLayout, pCurLayoutItem);
         delete pCurLayoutItem;
         pCurLayoutItem = pNextLayoutItem;
         continue;
       }
-      if (dwFlag & XFA_NODEFLAG_LayoutGeneratedNode) {
+      if (pCurLayoutItem->m_pFormNode->IsLayoutGeneratedNode()) {
         CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
             sIterator(pCurLayoutItem->m_pFormNode);
         for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
              pNode = sIterator.MoveToNext()) {
-          pNode->SetFlag(XFA_NODEFLAG_UnusedNode, false);
+          pNode->SetFlag(XFA_NodeFlag_UnusedNode, false);
         }
       }
     }
     if (pCurLayoutItem->m_pFirstChild) {
       SaveLayoutItem(pCurLayoutItem);
     }
     pCurLayoutItem->m_pParent = NULL;
     pCurLayoutItem->m_pNextSibling = NULL;
     pCurLayoutItem->m_pFirstChild = NULL;
     if (!pCurLayoutItem->IsContentLayoutItem() &&
@@ skipping 39 matching lines @@
           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->SetFlag(XFA_NODEFLAG_UnusedNode, true);
+        pNode->SetFlag(XFA_NodeFlag_UnusedNode, true);
       }
     }
   }
   int32_t iIndex = 0;
   for (; pRootLayout;
        pRootLayout = (CXFA_ContainerLayoutItem*)pRootLayout->m_pNextSibling) {
     CXFA_Node* pPendingPageSet = nullptr;
     CXFA_NodeIteratorTemplate<
         CXFA_ContainerLayoutItem,
         CXFA_TraverseStrategy_ContentAreaContainerLayoutItem>
@@ skipping 13 matching lines @@
       } else {
         pPendingPageSet = pRootPageSetContainerItem->m_pFormNode;
       }
     }
     if (pRootPageSetContainerItem->m_pFormNode->GetUserData(
             XFA_LAYOUTITEMKEY) == pRootPageSetContainerItem) {
       pRootPageSetContainerItem->m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY,
                                                           NULL);
     }
     pRootPageSetContainerItem->m_pFormNode = pPendingPageSet;
-    pPendingPageSet->ClearFlag(XFA_NODEFLAG_UnusedNode);
+    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->GetClassID()) {
         case XFA_ELEMENT_PageSet: {
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
           pContainerItem->m_pFormNode = XFA_NodeMerge_CloneOrMergeContainer(
@@ skipping 65 matching lines @@
       }
     }
     if (!pPendingPageSet->GetNodeItem(XFA_NODEITEM_Parent)) {
       CXFA_Node* pFormToplevelSubform =
           pDocument->GetXFAObject(XFA_HASHCODE_Form)
               ->AsNode()
               ->GetFirstChildByClass(XFA_ELEMENT_Subform);
       pFormToplevelSubform->InsertChild(pPendingPageSet);
     }
     pDocument->DataMerge_UpdateBindingRelations(pPendingPageSet);
-    pPendingPageSet->SetFlag(XFA_NODEFLAG_Initialized, true);
+    pPendingPageSet->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   CXFA_Node* pPageSet = GetRootLayoutItem()->m_pFormNode;
   while (pPageSet) {
     CXFA_Node* pNextPageSet =
         pPageSet->GetNextSameClassSibling(XFA_ELEMENT_PageSet);
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
         sIterator(pPageSet);
     CXFA_Node* pNode = sIterator.GetCurrent();
     while (pNode) {
-      if (pNode->HasFlag(XFA_NODEFLAG_UnusedNode)) {
-        if (pNode->GetObjectType() == XFA_OBJECTTYPE_ContainerNode) {
+      if (pNode->IsUnusedNode()) {
+        if (pNode->IsContainerNode()) {
           XFA_ELEMENT eCurId = pNode->GetClassID();
           if (eCurId == XFA_ELEMENT_PageArea || eCurId == XFA_ELEMENT_PageSet) {
             CXFA_ContainerIterator iteChild(pNode);
             CXFA_Node* pChildNode = iteChild.MoveToNext();
             for (; pChildNode; pChildNode = iteChild.MoveToNext()) {
               CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>(
                   pChildNode->GetUserData(XFA_LAYOUTITEMKEY));
               if (pLayoutItem) {
                 pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem);
                 delete pLayoutItem;
               }
             }
           } else if (eCurId != XFA_ELEMENT_ContentArea) {
             CXFA_LayoutItem* pLayoutItem = static_cast<CXFA_LayoutItem*>(
                 pNode->GetUserData(XFA_LAYOUTITEMKEY));
             if (pLayoutItem) {
               pNotify->OnLayoutItemRemoving(pDocLayout, pLayoutItem);
               delete pLayoutItem;
             }
           }
           CXFA_Node* pNext = sIterator.SkipChildrenAndMoveToNext();
           pNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pNode);
           pNode = pNext;
         } else {
-          pNode->ClearFlag(XFA_NODEFLAG_UnusedNode);
-          pNode->SetFlag(XFA_NODEFLAG_Initialized, true);
+          pNode->ClearFlag(XFA_NodeFlag_UnusedNode);
+          pNode->SetFlag(XFA_NodeFlag_Initialized, true);
           pNode = sIterator.MoveToNext();
         }
       } else {
-        pNode->SetFlag(XFA_NODEFLAG_Initialized, true);
+        pNode->SetFlag(XFA_NodeFlag_Initialized, true);
         pNode = sIterator.MoveToNext();
       }
     }
     pPageSet = pNextPageSet;
   }
 }
 
 void CXFA_LayoutPageMgr::LayoutPageSetContents() {
   CXFA_ContainerLayoutItem* pRootLayoutItem = GetRootLayoutItem();
   for (; pRootLayoutItem;
@@ skipping 92 matching lines @@
   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->HasFlag(XFA_NODEFLAG_HasRemoved)) {
+    if (pPageSetFormNode->HasRemovedChildren()) {
       XFA_ReleaseLayoutItem(pRootLayoutItem);
       m_pPageSetLayoutItemRoot = NULL;
       pRootLayoutItem = NULL;
       pPageSetFormNode = NULL;
       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;
   for (; pRootLayoutItem; pRootLayoutItem = pNextLayout) {
     pNextLayout = (CXFA_ContainerLayoutItem*)pRootLayoutItem->m_pNextSibling;
     SaveLayoutItem(pRootLayoutItem);
     delete pRootLayoutItem;
   }
   m_pPageSetLayoutItemRoot = NULL;
 }