Update GetClassID to GetElementType

xfa/fxfa/parser/xfa_document_datamerger_imp.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_document_datamerger_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
@@ skipping 55 matching lines @@
       XFA_DataMerge_FormValueNode_CreateChild(pValueNode, iType);
   if (!pChildNode)
     return FALSE;
 
   switch (pChildNode->GetObjectType()) {
     case XFA_ObjectType::ContentNode: {
       CXFA_Node* pContentRawDataNode =
           pChildNode->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         XFA_Element element = XFA_Element::Sharptext;
-        if (pChildNode->GetClassID() == XFA_Element::ExData) {
+        if (pChildNode->GetElementType() == XFA_Element::ExData) {
           CFX_WideString wsContentType;
           pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType,
                                    FALSE);
           if (wsContentType == FX_WSTRC(L"text/html")) {
             element = XFA_Element::SharpxHTML;
           } else if (wsContentType == FX_WSTRC(L"text/xml")) {
             element = XFA_Element::Sharpxml;
           }
         }
         pContentRawDataNode = pChildNode->CreateSamePacketNode(element);
@@ skipping 10 matching lines @@
       ASSERT(FALSE);
       break;
   }
   return TRUE;
 }
 static void XFA_DataMerge_CreateDataBinding(CXFA_Node* pFormNode,
                                             CXFA_Node* pDataNode,
                                             FX_BOOL bDataToForm = TRUE) {
   pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, pDataNode);
   pDataNode->AddBindItem(pFormNode);
-  XFA_Element eClass = pFormNode->GetClassID();
+  XFA_Element eClass = pFormNode->GetElementType();
   if (eClass != XFA_Element::Field && eClass != XFA_Element::ExclGroup) {
     return;
   }
   CXFA_WidgetData* pWidgetData = pFormNode->GetWidgetData();
   ASSERT(pWidgetData);
   XFA_Element eUIType = pWidgetData->GetUIType();
   CXFA_Value defValue(pFormNode->GetProperty(0, XFA_Element::Value));
   if (!bDataToForm) {
     CFX_WideString wsValue;
     CFX_WideString wsFormatedValue;
@@ skipping 48 matching lines @@
         if (wsValue.IsEmpty()) {
           break;
         }
         pWidgetData->GetFormatDataValue(wsValue, wsFormatedValue);
         pDataNode->SetAttributeValue(wsValue, wsFormatedValue);
         break;
       case XFA_Element::ExclGroup: {
         CXFA_Node* pChecked = NULL;
         CXFA_Node* pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
         for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-          if (pChild->GetClassID() != XFA_Element::Field) {
+          if (pChild->GetElementType() != XFA_Element::Field) {
             continue;
           }
           CXFA_Node* pValue = pChild->GetChild(0, XFA_Element::Value);
           if (!pValue) {
             continue;
           }
           CXFA_Value valueChild(pValue);
           valueChild.GetChildValueContent(wsValue);
           if (wsValue.IsEmpty()) {
             continue;
@@ skipping 16 matching lines @@
           }
         }
         if (!pChecked) {
           break;
         }
         pChild = pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
         for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
           if (pChild == pChecked) {
             continue;
           }
-          if (pChild->GetClassID() != XFA_Element::Field) {
+          if (pChild->GetElementType() != XFA_Element::Field) {
             continue;
           }
           CXFA_Node* pValue = pChild->GetProperty(0, XFA_Element::Value);
           CXFA_Node* pItems = pChild->GetChild(0, XFA_Element::Items);
           CXFA_Node* pText =
               pItems ? pItems->GetNodeItem(XFA_NODEITEM_FirstChild) : NULL;
           if (pText) {
             pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
           }
           CFX_WideString wsContent;
@@ skipping 136 matching lines @@
   for (CXFA_Node *pCurDataScope = pDataScope, *pLastDataScope = NULL;
        pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
        pLastDataScope = pCurDataScope,
                  pCurDataScope =
                      pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
     for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
          pDataChild;
          pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
       if (pDataChild == pLastDataScope ||
           (eMatchDataNodeType != XFA_Element::DataModel &&
-           pDataChild->GetClassID() != eMatchDataNodeType) ||
+           pDataChild->GetElementType() != eMatchDataNodeType) ||
           pDataChild->HasBindItem()) {
         continue;
       }
       return pDataChild;
     }
     for (CXFA_Node* pDataChild =
              pCurDataScope->GetFirstChildByClass(XFA_Element::DataGroup);
          pDataChild; pDataChild = pDataChild->GetNextSameClassSibling(
                          XFA_Element::DataGroup)) {
       CXFA_Node* pDataNode = XFA_DataMerge_ScopeMatchGlobalBinding(
@@ skipping 37 matching lines @@
   uint32_t dwNameHash = FX_HashCode_GetW(wsName, false);
   CXFA_Node* pLastDataScope = nullptr;
   for (CXFA_Node* pCurDataScope = pDataScope;
        pCurDataScope && pCurDataScope->GetPacketID() == XFA_XDPPACKET_Datasets;
        pCurDataScope = pCurDataScope->GetNodeItem(XFA_NODEITEM_Parent)) {
     for (CXFA_Node* pDataChild = pCurDataScope->GetFirstChildByName(dwNameHash);
          pDataChild;
          pDataChild = pDataChild->GetNextSameNameSibling(dwNameHash)) {
       if (pDataChild == pLastDataScope || pDataChild->HasBindItem() ||
           (eMatchNodeType != XFA_Element::DataModel &&
-           pDataChild->GetClassID() != eMatchNodeType)) {
+           pDataChild->GetElementType() != eMatchNodeType)) {
         continue;
       }
       return pDataChild;
     }
     pLastDataScope = pCurDataScope;
   }
   return nullptr;
 }
 
 static CXFA_Node* XFA_DataMerge_FindDataRefDataNode(CXFA_Document* pDocument,
@@ skipping 25 matching lines @@
   }
   return NULL;
 }
 CXFA_Node* XFA_DataMerge_FindFormDOMInstance(CXFA_Document* pDocument,
                                              XFA_Element eClassID,
                                              uint32_t dwNameHash,
                                              CXFA_Node* pFormParent) {
   CXFA_Node* pFormChild = pFormParent->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pFormChild;
        pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pFormChild->GetClassID() == eClassID &&
+    if (pFormChild->GetElementType() == eClassID &&
         pFormChild->GetNameHash() == dwNameHash && pFormChild->IsUnusedNode()) {
       return pFormChild;
     }
   }
   return NULL;
 }
 static FX_BOOL XFA_NeedGenerateForm(CXFA_Node* pTemplateChild,
                                     FX_BOOL bUseInstanceManager = TRUE) {
-  XFA_Element eType = pTemplateChild->GetClassID();
+  XFA_Element eType = pTemplateChild->GetElementType();
   if (eType == XFA_Element::Variables) {
     return TRUE;
   }
   if (pTemplateChild->IsContainerNode()) {
     return FALSE;
   }
   if (eType == XFA_Element::Proto ||
       (bUseInstanceManager && eType == XFA_Element::Occur)) {
     return FALSE;
   }
   return TRUE;
 }
 CXFA_Node* XFA_NodeMerge_CloneOrMergeContainer(CXFA_Document* pDocument,
                                                CXFA_Node* pFormParent,
                                                CXFA_Node* pTemplateNode,
                                                FX_BOOL bRecursive,
                                                CXFA_NodeArray* pSubformArray) {
   CXFA_Node* pExistingNode = NULL;
   if (pSubformArray == NULL) {
     pExistingNode = XFA_DataMerge_FindFormDOMInstance(
-        pDocument, pTemplateNode->GetClassID(), pTemplateNode->GetNameHash(),
-        pFormParent);
+        pDocument, pTemplateNode->GetElementType(),
+        pTemplateNode->GetNameHash(), pFormParent);
   } else if (pSubformArray->GetSize() > 0) {
     pExistingNode = pSubformArray->GetAt(0);
     pSubformArray->RemoveAt(0);
   }
   if (pExistingNode) {
     if (pSubformArray) {
       pFormParent->InsertChild(pExistingNode);
     } else if (pExistingNode->IsContainerNode()) {
       pFormParent->RemoveChild(pExistingNode);
       pFormParent->InsertChild(pExistingNode);
     }
     pExistingNode->ClearFlag(XFA_NodeFlag_UnusedNode);
     pExistingNode->SetTemplateNode(pTemplateNode);
-    if (bRecursive && pExistingNode->GetClassID() != XFA_Element::Items) {
+    if (bRecursive && pExistingNode->GetElementType() != XFA_Element::Items) {
       for (CXFA_Node* pTemplateChild =
                pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
            pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
         if (XFA_NeedGenerateForm(pTemplateChild)) {
           XFA_NodeMerge_CloneOrMergeContainer(pDocument, pExistingNode,
                                               pTemplateChild, bRecursive);
         }
       }
     }
@@ skipping 24 matching lines @@
   CFX_WideString wsInstMgrNodeName = FX_WSTRC(L"_") + wsSubformName;
   uint32_t dwInstNameHash =
       FX_HashCode_GetW(wsInstMgrNodeName.AsStringC(), false);
   CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance(
       pDocument, XFA_Element::InstanceManager, dwInstNameHash, pFormParent);
   if (pExistingNode) {
     uint32_t dwNameHash = pTemplateNode->GetNameHash();
     for (CXFA_Node* pNode =
              pExistingNode->GetNodeItem(XFA_NODEITEM_NextSibling);
          pNode;) {
-      XFA_Element eCurType = pNode->GetClassID();
+      XFA_Element eCurType = pNode->GetElementType();
       if (eCurType == XFA_Element::InstanceManager) {
         break;
       }
       if ((eCurType != XFA_Element::Subform) &&
           (eCurType != XFA_Element::SubformSet)) {
         pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
         continue;
       }
       if (dwNameHash != pNode->GetNameHash()) {
         break;
@@ skipping 34 matching lines @@
   FX_BOOL bOwnIterator = FALSE;
   if (!pIterator) {
     bOwnIterator = TRUE;
     pIterator = new CXFA_NodeIteratorTemplate<
         CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>(pTemplateNode);
   }
   CXFA_Node* pResult = NULL;
   for (CXFA_Node* pCurTemplateNode = pIterator->GetCurrent();
        pCurTemplateNode;) {
     XFA_Element eMatchNodeType;
-    switch (pCurTemplateNode->GetClassID()) {
+    switch (pCurTemplateNode->GetElementType()) {
       case XFA_Element::Subform:
         eMatchNodeType = XFA_Element::DataGroup;
         break;
       case XFA_Element::Field: {
         eMatchNodeType = XFA_FieldIsMultiListBox(pCurTemplateNode)
                              ? XFA_Element::DataGroup
                              : XFA_Element::DataValue;
       } break;
       case XFA_Element::ExclGroup:
         eMatchNodeType = XFA_Element::DataValue;
@@ skipping 49 matching lines @@
           continue;
         }
         pResult = pOnceBindNode;
       } break;
       case XFA_ATTRIBUTEENUM_DataRef: {
         bAccessedDataDOM = TRUE;
         CXFA_Node* pDataRefBindNode = XFA_DataMerge_FindDataRefDataNode(
             pDocument, pTemplateNodeBind->GetCData(XFA_ATTRIBUTE_Ref),
             pDataScope, eMatchNodeType, pTemplateNode, bForceBind, bUpLevel);
         if (pDataRefBindNode &&
-            pDataRefBindNode->GetClassID() == eMatchNodeType) {
+            pDataRefBindNode->GetElementType() == eMatchNodeType) {
           pResult = pDataRefBindNode;
         }
         if (!pResult) {
           pCurTemplateNode = pIterator->SkipChildrenAndMoveToNext();
           continue;
         }
       } break;
       default:
         break;
     }
@@ skipping 43 matching lines @@
     rgRecords.Copy(rgResultRecord);
   }
 }
 static CXFA_Node* XFA_DataMerge_CopyContainer_SubformSet(
     CXFA_Document* pDocument,
     CXFA_Node* pTemplateNode,
     CXFA_Node* pFormParentNode,
     CXFA_Node* pDataScope,
     FX_BOOL bOneInstance,
     FX_BOOL bDataMerge) {
-  XFA_Element eElement = pTemplateNode->GetClassID();
+  XFA_Element eElement = pTemplateNode->GetElementType();
   CXFA_Node* pOccurNode = NULL;
   CXFA_Node* pFirstInstance = NULL;
   FX_BOOL bUseInstanceManager =
-      pFormParentNode->GetClassID() != XFA_Element::Area;
+      pFormParentNode->GetElementType() != XFA_Element::Area;
   CXFA_Node* pInstMgrNode = NULL;
   CXFA_NodeArray subformArray;
   CXFA_NodeArray* pSearchArray = NULL;
   if (!bOneInstance && (eElement == XFA_Element::SubformSet ||
                         eElement == XFA_Element::Subform)) {
     pInstMgrNode =
         bUseInstanceManager
             ? XFA_NodeMerge_CloneOrMergeInstanceManager(
                   pDocument, pFormParentNode, pTemplateNode, subformArray)
             : NULL;
     if (CXFA_Node* pOccurTemplateNode =
             pTemplateNode->GetFirstChildByClass(XFA_Element::Occur)) {
       pOccurNode = pInstMgrNode
                        ? XFA_NodeMerge_CloneOrMergeContainer(
                              pDocument, pInstMgrNode, pOccurTemplateNode, FALSE)
                        : pOccurTemplateNode;
     } else if (pInstMgrNode) {
       pOccurNode = pInstMgrNode->GetFirstChildByClass(XFA_Element::Occur);
       if (pOccurNode) {
         pOccurNode->ClearFlag(XFA_NodeFlag_UnusedNode);
       }
     }
     if (pInstMgrNode) {
       pInstMgrNode->SetFlag(XFA_NodeFlag_Initialized, true);
       pSearchArray = &subformArray;
-      if (pFormParentNode->GetClassID() == XFA_Element::PageArea) {
+      if (pFormParentNode->GetElementType() == XFA_Element::PageArea) {
         bOneInstance = TRUE;
         if (subformArray.GetSize() < 1) {
           pSearchArray = NULL;
         }
       } else if ((pTemplateNode->GetNameHash() == 0) &&
                  (subformArray.GetSize() < 1)) {
         pSearchArray = NULL;
       }
     }
   }
@@ skipping 162 matching lines @@
       }
       for (; (iLimit < 0 || iCurRepeatIndex < iLimit); iCurRepeatIndex++) {
         if (pInstMgrNode) {
           if (pSearchArray && pSearchArray->GetSize() < 1) {
             if (pTemplateNode->GetNameHash() != 0) {
               break;
             }
             pSearchArray = NULL;
           }
         } else if (!XFA_DataMerge_FindFormDOMInstance(
-                       pDocument, pTemplateNode->GetClassID(),
+                       pDocument, pTemplateNode->GetElementType(),
                        pTemplateNode->GetNameHash(), pFormParentNode)) {
           break;
         }
         CXFA_Node* pSubformNode = XFA_NodeMerge_CloneOrMergeContainer(
             pDocument, pFormParentNode, pTemplateNode, FALSE, pSearchArray);
         ASSERT(pSubformNode);
         if (!pFirstInstance) {
           pFirstInstance = pSubformNode;
         }
         for (CXFA_Node* pTemplateChild =
@@ skipping 48 matching lines @@
   CXFA_Node* pFieldNode = XFA_NodeMerge_CloneOrMergeContainer(
       pDocument, pFormNode, pTemplateNode, FALSE);
   ASSERT(pFieldNode);
   for (CXFA_Node* pTemplateChildNode =
            pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pTemplateChildNode; pTemplateChildNode = pTemplateChildNode->GetNodeItem(
                                XFA_NODEITEM_NextSibling)) {
     if (XFA_NeedGenerateForm(pTemplateChildNode)) {
       XFA_NodeMerge_CloneOrMergeContainer(pDocument, pFieldNode,
                                           pTemplateChildNode, TRUE);
-    } else if (pTemplateNode->GetClassID() == XFA_Element::ExclGroup &&
+    } else if (pTemplateNode->GetElementType() == XFA_Element::ExclGroup &&
                pTemplateChildNode->IsContainerNode()) {
-      if (pTemplateChildNode->GetClassID() == XFA_Element::Field) {
+      if (pTemplateChildNode->GetElementType() == XFA_Element::Field) {
         XFA_DataMerge_CopyContainer_Field(pDocument, pTemplateChildNode,
                                           pFieldNode, NULL, FALSE);
       }
     }
   }
   if (bDataMerge) {
     FX_BOOL bAccessedDataDOM = FALSE;
     FX_BOOL bSelfMatch = FALSE;
     XFA_ATTRIBUTEENUM eBindMatch;
     CXFA_Node* pDataNode = XFA_DataMerge_FindMatchingDataNode(
         pDocument, pTemplateNode, pDataScope, bAccessedDataDOM, TRUE, NULL,
         bSelfMatch, eBindMatch, bUpLevel);
     if (pDataNode) {
       XFA_DataMerge_CreateDataBinding(pFieldNode, pDataNode);
     }
   } else {
     XFA_DataMerge_FormValueNode_MatchNoneCreateChild(pFieldNode);
   }
   return pFieldNode;
 }
 CXFA_Node* CXFA_Document::DataMerge_CopyContainer(CXFA_Node* pTemplateNode,
                                                   CXFA_Node* pFormNode,
                                                   CXFA_Node* pDataScope,
                                                   FX_BOOL bOneInstance,
                                                   FX_BOOL bDataMerge,
                                                   FX_BOOL bUpLevel) {
-  switch (pTemplateNode->GetClassID()) {
+  switch (pTemplateNode->GetElementType()) {
     case XFA_Element::SubformSet:
     case XFA_Element::Subform:
     case XFA_Element::Area:
     case XFA_Element::PageArea:
       return XFA_DataMerge_CopyContainer_SubformSet(
           this, pTemplateNode, pFormNode, pDataScope, bOneInstance, bDataMerge);
     case XFA_Element::ExclGroup:
     case XFA_Element::Field:
     case XFA_Element::Draw:
     case XFA_Element::ContentArea:
       return XFA_DataMerge_CopyContainer_Field(
           this, pTemplateNode, pFormNode, pDataScope, bDataMerge, bUpLevel);
     case XFA_Element::PageSet:
       break;
     case XFA_Element::Variables:
       break;
     default:
       ASSERT(FALSE);
       break;
   }
   return NULL;
 }
 
 static void XFA_DataMerge_UpdateBindingRelations(CXFA_Document* pDocument,
                                                  CXFA_Node* pFormNode,
                                                  CXFA_Node* pDataScope,
                                                  FX_BOOL bDataRef,
                                                  FX_BOOL bParentDataRef) {
   FX_BOOL bMatchRef = TRUE;
-  XFA_Element eClassID = pFormNode->GetClassID();
+  XFA_Element eClassID = pFormNode->GetElementType();

[Lei Zhang, 2016/06/23 05:04:19]

BTW, there's still some variables referencing class id.

   CXFA_Node* pDataNode = pFormNode->GetBindData();
   if (eClassID == XFA_Element::Subform || eClassID == XFA_Element::ExclGroup ||
       eClassID == XFA_Element::Field) {
     CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
     CXFA_Node* pTemplateNodeBind =
         pTemplateNode ? pTemplateNode->GetFirstChildByClass(XFA_Element::Bind)
                       : NULL;
     XFA_ATTRIBUTEENUM eMatch =
         pTemplateNodeBind ? pTemplateNodeBind->GetEnum(XFA_ATTRIBUTE_Match)
                           : XFA_ATTRIBUTEENUM_Once;
@@ skipping 152 matching lines @@
     m_pRootNode->InsertChild(pDatasetsRoot);
     pDatasetsRoot->SetXMLMappingNode(pDatasetsXMLNode);
   }
   CXFA_Node *pDataRoot = NULL, *pDDRoot = NULL;
   CFX_WideString wsDatasetsURI;
   pDatasetsRoot->TryNamespace(wsDatasetsURI);
   for (CXFA_Node* pChildNode =
            pDatasetsRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
        pChildNode;
        pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-    if (pChildNode->GetClassID() != XFA_Element::DataGroup) {
+    if (pChildNode->GetElementType() != XFA_Element::DataGroup) {
       continue;
     }
     CFX_WideString wsNamespaceURI;
     if (!pDDRoot && pChildNode->GetNameHash() == XFA_HASHCODE_DataDescription) {
       if (!pChildNode->TryNamespace(wsNamespaceURI)) {
         continue;
       }
       if (wsNamespaceURI ==
           FX_WSTRC(L"http://ns.adobe.com/data-description/")) {
         pDDRoot = pChildNode;
@@ skipping 21 matching lines @@
       pDataRoot->GetFirstChildByClass(XFA_Element::DataGroup);
   uint32_t dwNameHash = pDataTopLevel ? pDataTopLevel->GetNameHash() : 0;
   CXFA_Node* pTemplateRoot =
       m_pRootNode->GetFirstChildByClass(XFA_Element::Template);
   if (!pTemplateRoot) {
     return;
   }
   CXFA_Node* pTemplateChosen =
       dwNameHash != 0 ? pTemplateRoot->GetFirstChildByName(dwNameHash) : NULL;
   if (!pTemplateChosen ||
-      pTemplateChosen->GetClassID() != XFA_Element::Subform) {
+      pTemplateChosen->GetElementType() != XFA_Element::Subform) {
     pTemplateChosen = pTemplateRoot->GetFirstChildByClass(XFA_Element::Subform);
   }
   if (!pTemplateChosen) {
     return;
   }
   CXFA_Node* pFormRoot = m_pRootNode->GetFirstChildByClass(XFA_Element::Form);
   FX_BOOL bEmptyForm = FALSE;
   if (!pFormRoot) {
     bEmptyForm = TRUE;
     pFormRoot = CreateNode(XFA_XDPPACKET_Form, XFA_Element::Form);
@@ skipping 50 matching lines @@
     pSubformSetNode->RemoveChild(pPageSetNode);
     pPageSetNode = pNextPageSetNode;
   }
   if (!bEmptyForm) {
     CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode>
         sIterator(pFormRoot);
     CXFA_Node* pNode = sIterator.MoveToNext();
     while (pNode) {
       if (pNode->IsUnusedNode()) {
         if (pNode->IsContainerNode() ||
-            pNode->GetClassID() == XFA_Element::InstanceManager) {
+            pNode->GetElementType() == XFA_Element::InstanceManager) {
           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 = sIterator.MoveToNext();
         }
       } else {
         pNode->SetFlag(XFA_NodeFlag_Initialized, true);
@@ skipping 10 matching lines @@
     }
     pFormRoot->SetObject(XFA_ATTRIBUTE_BindingNode, NULL);
   }
   XFA_DataMerge_ClearGlobalBinding(this);
   if (bDoDataMerge) {
     DoDataMerge();
   }
   CXFA_LayoutProcessor* pLayoutProcessor = GetLayoutProcessor();
   pLayoutProcessor->SetForceReLayout(TRUE);
 }