Remove uses of this->foo.

xfa/src/fxfa/src/parser/xfa_object_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/src/foxitlib.h"
 #include "xfa/src/fxfa/src/common/xfa_docdata.h"
 #include "xfa/src/fxfa/src/common/xfa_doclayout.h"
 #include "xfa/src/fxfa/src/common/xfa_document.h"
@@ skipping 102 matching lines @@
   CXFA_Node* pClone = pFactory->CreateNode(m_ePacket, m_eNodeClass);
   if (!pClone) {
     return NULL;
   }
   MergeAllData(pClone);
   pClone->UpdateNameHash();
   if (IsNeedSavingXMLNode()) {
     IFDE_XMLNode* pCloneXML = NULL;
     if (IsAttributeInXML()) {
       CFX_WideString wsName;
-      this->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
+      GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
       IFDE_XMLElement* pCloneXMLElement = IFDE_XMLElement::Create(wsName);
-      CFX_WideStringC wsValue = this->GetCData(XFA_ATTRIBUTE_Value);
+      CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pCloneXMLElement->SetTextData(wsValue);
       }
       pCloneXML = pCloneXMLElement;
       pCloneXMLElement = NULL;
       pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       pCloneXML = m_pXMLNode->Clone(FALSE);
     }
     pClone->SetXMLMappingNode(pCloneXML);
@@ skipping 281 matching lines @@
   }
   XFA_ELEMENT classID = GetClassID();
   if (classID == XFA_ELEMENT_ExclGroup) {
     return NULL;
   }
   CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
   if (pParentNode && pParentNode->GetClassID() == XFA_ELEMENT_ExclGroup) {
     return NULL;
   }
   if (classID == XFA_ELEMENT_Field) {
-    CXFA_WidgetData* pFieldWidgetData = this->GetWidgetData();
+    CXFA_WidgetData* pFieldWidgetData = GetWidgetData();
     if (pFieldWidgetData &&
         pFieldWidgetData->GetChoiceListOpen() ==
             XFA_ATTRIBUTEENUM_MultiSelect) {
       return NULL;
     } else {
       CFX_WideString wsPicture;
       if (pFieldWidgetData) {
         pFieldWidgetData->GetPictureContent(wsPicture,
                                             XFA_VALUEPICTURE_DataBind);
       }
       if (!wsPicture.IsEmpty()) {
         return pFieldWidgetData;
       }
-      CXFA_Node* pDataNode = this->GetBindData();
+      CXFA_Node* pDataNode = GetBindData();
       if (!pDataNode) {
         return NULL;
       }
       pFieldWidgetData = NULL;
       CXFA_NodeArray formNodes;
       pDataNode->GetBindItems(formNodes);
       for (int32_t i = 0; i < formNodes.GetSize(); i++) {
         CXFA_Node* pFormNode = formNodes.GetAt(i);
         if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
           continue;
@@ skipping 109 matching lines @@
         case XFA_ATTRIBUTEENUM_Tb:
         case XFA_ATTRIBUTEENUM_Table:
         case XFA_ATTRIBUTEENUM_Lr_tb:
         case XFA_ATTRIBUTEENUM_Rl_tb:
           return XFA_ATTRIBUTEENUM_None;
         default:
           break;
       }
       break;
     case XFA_ELEMENT_Field: {
-      CXFA_Node* pParentNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+      CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
       if (!pParentNode || pParentNode->GetClassID() == XFA_ELEMENT_PageArea) {
         return XFA_ATTRIBUTEENUM_ContentArea;
       }
       if (pParentNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
         XFA_ATTRIBUTEENUM eParLayout =
             pParentNode->GetEnum(XFA_ATTRIBUTE_Layout);
         if (eParLayout == XFA_ATTRIBUTEENUM_Position ||
             eParLayout == XFA_ATTRIBUTEENUM_Row ||
             eParLayout == XFA_ATTRIBUTEENUM_Table) {
           return XFA_ATTRIBUTEENUM_None;
         }
         XFA_VERSION version = m_pDocument->GetCurVersionMode();
         if (eParLayout == XFA_ATTRIBUTEENUM_Tb && version < XFA_VERSION_208) {
           CXFA_Measurement measureH;
-          if (this->TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE)) {
+          if (TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE)) {
             return XFA_ATTRIBUTEENUM_ContentArea;
           }
         }
         return XFA_ATTRIBUTEENUM_None;
       }
       return XFA_ATTRIBUTEENUM_ContentArea;
     }
     case XFA_ELEMENT_Draw:
       return XFA_ATTRIBUTEENUM_ContentArea;
     default:
@@ skipping 148 matching lines @@
   }
 }
 void CXFA_Node::Script_TreeClass_ClassAll(FXJSE_HVALUE hValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     FX_DWORD dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
     CFX_WideStringC wsName;
-    this->GetClassName(wsName);
+    GetClassName(wsName);
     CFX_WideString wsExpression = FX_WSTRC(L"#") + wsName + FX_WSTRC(L"[*]");
     Script_Som_ResolveNodeList(hValue, wsExpression, dwFlag);
   }
 }
 void CXFA_Node::Script_TreeClass_Parent(FXJSE_HVALUE hValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
-    CXFA_Node* pParent = this->GetNodeItem(XFA_NODEITEM_Parent);
+    CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
     if (pParent) {
       FXJSE_Value_Set(
           hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(pParent));
     } else {
       FXJSE_Value_SetNull(hValue);
     }
   }
 }
 void CXFA_Node::Script_TreeClass_Index(FXJSE_HVALUE hValue,
                                        FX_BOOL bSetting,
@@ skipping 58 matching lines @@
   }
 }
 void CXFA_Node::Script_NodeClass_Clone(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clone");
     return;
   }
   FX_BOOL bClone = TRUE;
   bClone = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
-  CXFA_Node* pCloneNode = this->Clone(bClone);
+  CXFA_Node* pCloneNode = Clone(bClone);
   FXJSE_Value_Set(
       pArguments->GetReturnValue(),
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pCloneNode));
 }
 void CXFA_Node::Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"getAttribute");
     return;
   }
   CFX_WideString wsExpression;
   CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
   wsExpression =
       CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
   CFX_WideString wsValue;
-  this->GetAttribute(wsExpression, wsValue);
+  GetAttribute(wsExpression, wsValue);
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
     FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue));
   }
 }
 void CXFA_Node::Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getElement");
     return;
   }
   CFX_WideString wsExpression;
   int32_t iValue = 0;
   if (iLength >= 1) {
     CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
     wsExpression =
         CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
   }
   if (iLength >= 2) {
     iValue = pArguments->GetInt32(1);
   }
   const XFA_ELEMENTINFO* pElementInfo = XFA_GetElementByName(wsExpression);
-  CXFA_Node* pNode = this->GetProperty(iValue, pElementInfo->eName);
+  CXFA_Node* pNode = GetProperty(iValue, pElementInfo->eName);
   FXJSE_Value_Set(pArguments->GetReturnValue(),
                   m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
 }
 void CXFA_Node::Script_NodeClass_IsPropertySpecified(
     CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"isPropertySpecified");
     return;
@@ skipping 10 matching lines @@
     bParent = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
   }
   if (iLength >= 3) {
     iIndex = pArguments->GetInt32(2);
   }
   FX_BOOL bHas = FALSE;
   const XFA_ATTRIBUTEINFO* pAttributeInfo =
       XFA_GetAttributeByName(wsExpression);
   CFX_WideString wsValue;
   if (pAttributeInfo) {
-    bHas = this->HasAttribute(pAttributeInfo->eName);
+    bHas = HasAttribute(pAttributeInfo->eName);
   }
   if (!bHas) {
     const XFA_ELEMENTINFO* pElementInfo = XFA_GetElementByName(wsExpression);
-    bHas = (this->GetProperty(iIndex, pElementInfo->eName) != NULL);
+    bHas = (GetProperty(iIndex, pElementInfo->eName) != NULL);
   }
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
     FXJSE_Value_SetBoolean(hValue, bHas);
   }
 }
 void CXFA_Node::Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"loadXML");
@@ skipping 24 matching lines @@
   int32_t iParserStatus = pParser->ParseXMLData(wsExpression, pXMLNode, NULL);
   if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode) {
     pParser->Release();
     pParser = NULL;
     return;
   }
   if (bIgnoreRoot && (pXMLNode->GetType() != FDE_XMLNODE_Element ||
                       XFA_RecognizeRichText((IFDE_XMLElement*)pXMLNode))) {
     bIgnoreRoot = FALSE;
   }
-  CXFA_Node* pFakeRoot = this->Clone(FALSE);
-  CFX_WideStringC wsContentType = this->GetCData(XFA_ATTRIBUTE_ContentType);
+  CXFA_Node* pFakeRoot = Clone(FALSE);
+  CFX_WideStringC wsContentType = GetCData(XFA_ATTRIBUTE_ContentType);
   if (!wsContentType.IsEmpty()) {
     pFakeRoot->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
   }
   IFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode();
   if (!pFakeXMLRoot) {
-    IFDE_XMLNode* pThisXMLRoot = this->GetXMLMappingNode();
+    IFDE_XMLNode* pThisXMLRoot = GetXMLMappingNode();
     pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : NULL;
   }
   if (!pFakeXMLRoot) {
     CFX_WideStringC wsClassName;
-    this->GetClassName(wsClassName);
+    GetClassName(wsClassName);
     pFakeXMLRoot = IFDE_XMLElement::Create(wsClassName);
   }
   if (bIgnoreRoot) {
     IFDE_XMLNode* pXMLChild = pXMLNode->GetNodeItem(IFDE_XMLNode::FirstChild);
     while (pXMLChild) {
       IFDE_XMLNode* pXMLSibling =
           pXMLChild->GetNodeItem(IFDE_XMLNode::NextSibling);
       pXMLNode->RemoveChildNode(pXMLChild);
       pFakeXMLRoot->InsertChildNode(pXMLChild);
       pXMLChild = pXMLSibling;
     }
   } else {
     IFDE_XMLNode* pXMLParent = pXMLNode->GetNodeItem(IFDE_XMLNode::Parent);
     if (pXMLParent) {
       pXMLParent->RemoveChildNode(pXMLNode);
     }
     pFakeXMLRoot->InsertChildNode(pXMLNode);
   }
   pParser->ConstructXFANode(pFakeRoot, pFakeXMLRoot);
   pFakeRoot = pParser->GetRootNode();
   if (pFakeRoot) {
     if (bOverwrite) {
-      CXFA_Node* pChild = this->GetNodeItem(XFA_NODEITEM_FirstChild);
+      CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild);
       CXFA_Node* pNewChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
       int32_t index = 0;
       while (pNewChild) {
         CXFA_Node* pItem = pNewChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         pFakeRoot->RemoveChild(pNewChild);
-        this->InsertChild(index++, pNewChild);
+        InsertChild(index++, pNewChild);
         pNewChild->SetFlag(XFA_NODEFLAG_Initialized);
         pNewChild = pItem;
       }
       while (pChild) {
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
-        this->RemoveChild(pChild);
+        RemoveChild(pChild);
         pFakeRoot->InsertChild(pChild);
         pChild = pItem;
       }
       if (GetPacketID() == XFA_XDPPACKET_Form &&
           GetClassID() == XFA_ELEMENT_ExData) {
-        IFDE_XMLNode* pTempXMLNode = this->GetXMLMappingNode();
-        this->SetXMLMappingNode(pFakeXMLRoot);
-        this->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+        IFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
+        SetXMLMappingNode(pFakeXMLRoot);
+        SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
         if (pTempXMLNode &&
             pTempXMLNode->GetNodeItem(IFDE_XMLNode::Parent) == NULL) {
           pFakeXMLRoot = pTempXMLNode;
         } else {
           pFakeXMLRoot = NULL;
         }
       }
       MoveBufferMapData(pFakeRoot, this, XFA_CalcData, TRUE);
     } else {
       CXFA_Node* pChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
       while (pChild) {
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         pFakeRoot->RemoveChild(pChild);
-        this->InsertChild(pChild);
+        InsertChild(pChild);
         pChild->SetFlag(XFA_NODEFLAG_Initialized);
         pChild = pItem;
       }
     }
     if (pFakeXMLRoot) {
       pFakeRoot->SetXMLMappingNode(pFakeXMLRoot);
       pFakeRoot->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
     }
     pFakeRoot->SetFlag(XFA_NODEFLAG_HasRemoved, TRUE, FALSE);
   } else {
@@ skipping 43 matching lines @@
         CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
     pStream->Release();
     pStream = NULL;
     if (pMemoryStream) {
       pMemoryStream->Release();
       pMemoryStream = NULL;
     }
     return;
   }
   if (GetPacketID() == XFA_XDPPACKET_Datasets) {
-    IFDE_XMLNode* pElement = this->GetXMLMappingNode();
+    IFDE_XMLNode* pElement = GetXMLMappingNode();
     if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
       FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
       return;
     }
     XFA_DataExporter_DealWithDataGroupNode(this);
     IFX_MemoryStream* pMemoryStream = FX_CreateMemoryStream(TRUE);
     IFX_Stream* pStream = IFX_Stream::CreateStream(
         (IFX_FileWrite*)pMemoryStream,
         FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
     if (pStream) {
@@ skipping 22 matching lines @@
                             L"setAttribute");
     return;
   }
   CFX_WideString wsAttribute;
   CFX_WideString wsAttributeValue;
   CFX_ByteString bsAttributeValue = pArguments->GetUTF8String(0);
   CFX_ByteString bsAttribute = pArguments->GetUTF8String(1);
   wsAttributeValue =
       CFX_WideString::FromUTF8(bsAttributeValue, bsAttributeValue.GetLength());
   wsAttribute = CFX_WideString::FromUTF8(bsAttribute, bsAttribute.GetLength());
-  this->SetAttribute(wsAttribute, wsAttributeValue, TRUE);
+  SetAttribute(wsAttribute, wsAttributeValue, TRUE);
 }
 void CXFA_Node::Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1 && iLength != 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setElement");
     return;
   }
   CXFA_Node* pNode = NULL;
   CFX_WideString wsName;
   if (iLength >= 1) {
     pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
   }
   if (iLength >= 2) {
     CFX_ByteString bsName = pArguments->GetUTF8String(1);
     wsName = CFX_WideString::FromUTF8(bsName, bsName.GetLength());
   }
 }
 void CXFA_Node::Script_NodeClass_Ns(FXJSE_HVALUE hValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsNameSpace;
-    this->TryNamespace(wsNameSpace);
+    TryNamespace(wsNameSpace);
     FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsNameSpace));
   }
 }
 void CXFA_Node::Script_NodeClass_Model(FXJSE_HVALUE hValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     FXJSE_Value_Set(hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(
-                                this->GetModelNode()));
+                                GetModelNode()));
   }
 }
 void CXFA_Node::Script_NodeClass_IsContainer(FXJSE_HVALUE hValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
-    FXJSE_Value_SetBoolean(hValue, this->IsContainerNode());
+    FXJSE_Value_SetBoolean(hValue, IsContainerNode());
   }
 }
 void CXFA_Node::Script_NodeClass_IsNull(FXJSE_HVALUE hValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
-    if (this->GetClassID() == XFA_ELEMENT_Subform) {
+    if (GetClassID() == XFA_ELEMENT_Subform) {
       FXJSE_Value_SetBoolean(hValue, FALSE);
       return;
     }
     CFX_WideString strValue;
     FXJSE_Value_SetBoolean(hValue, !TryContent(strValue) || strValue.IsEmpty());
   }
 }
 void CXFA_Node::Script_NodeClass_OneOfChild(FXJSE_HVALUE hValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_NodeArray properts;
-    int32_t iSize = this->GetNodeList(properts, XFA_NODEFILTER_OneOfProperty);
+    int32_t iSize = GetNodeList(properts, XFA_NODEFILTER_OneOfProperty);
     if (iSize > 0) {
       FXJSE_Value_Set(
           hValue,
           m_pDocument->GetScriptContext()->GetJSValueFromMap(properts[0]));
     }
   }
 }
 void CXFA_Node::Script_ContainerClass_GetDelta(CFXJSE_Arguments* pArguments) {}
 void CXFA_Node::Script_ContainerClass_GetDeltas(CFXJSE_Arguments* pArguments) {
   CXFA_ArrayNodeList* pFormNodes = new CXFA_ArrayNodeList(m_pDocument);
@@ skipping 12 matching lines @@
                             L"isCompatibleNS");
     return;
   }
   CFX_WideString wsNameSpace;
   if (iLength >= 1) {
     CFX_ByteString bsNameSpace = pArguments->GetUTF8String(0);
     wsNameSpace =
         CFX_WideString::FromUTF8(bsNameSpace, bsNameSpace.GetLength());
   }
   CFX_WideString wsNodeNameSpace;
-  this->TryNamespace(wsNodeNameSpace);
+  TryNamespace(wsNodeNameSpace);
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
     FXJSE_Value_SetBoolean(hValue, wsNodeNameSpace.Equal(wsNameSpace));
   }
 }
 void CXFA_Node::Script_ModelClass_Context(FXJSE_HVALUE hValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {}
 void CXFA_Node::Script_ModelClass_AliasNode(FXJSE_HVALUE hValue,
                                             FX_BOOL bSetting,
@@ skipping 39 matching lines @@
     void* eValue,
     FX_BOOL bScriptModify) {
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
   if (!pNotify) {
     return;
   }
-  FX_DWORD dwPacket = this->GetPacketID();
+  FX_DWORD dwPacket = GetPacketID();
   if (dwPacket & XFA_XDPPACKET_Form) {
     FX_BOOL bNeedFindContainer = FALSE;
-    XFA_ELEMENT eType = this->GetClassID();
+    XFA_ELEMENT eType = GetClassID();
     switch (eType) {
       case XFA_ELEMENT_Caption:
         bNeedFindContainer = TRUE;
         pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
-                             eValue, this,
-                             this->GetNodeItem(XFA_NODEITEM_Parent));
+                             eValue, this, GetNodeItem(XFA_NODEITEM_Parent));
         break;
       case XFA_ELEMENT_Font:
       case XFA_ELEMENT_Para: {
         bNeedFindContainer = TRUE;
-        CXFA_Node* pParentNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+        CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParentNode->GetClassID() == XFA_ELEMENT_Caption) {
           pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                                eValue, pParentNode,
                                pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
         } else {
           pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                                eValue, this, pParentNode);
         }
       } break;
       case XFA_ELEMENT_Margin: {
         bNeedFindContainer = TRUE;
-        CXFA_Node* pParentNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+        CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
         XFA_ELEMENT eParentType = pParentNode->GetClassID();
         if (pParentNode->IsContainerNode()) {
           pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                                eValue, this, pParentNode);
         } else if (eParentType == XFA_ELEMENT_Caption) {
           pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                                eValue, pParentNode,
                                pParentNode->GetNodeItem(XFA_NODEITEM_Parent));
         } else {
           CXFA_Node* pNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
           if (pNode && pNode->GetClassID() == XFA_ELEMENT_Ui) {
             pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                                  eValue, pNode,
                                  pNode->GetNodeItem(XFA_NODEITEM_Parent));
           }
         }
       } break;
       case XFA_ELEMENT_Comb: {
-        CXFA_Node* pEditNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+        CXFA_Node* pEditNode = GetNodeItem(XFA_NODEITEM_Parent);
         XFA_ELEMENT eUIType = pEditNode->GetClassID();
         if (pEditNode && (eUIType == XFA_ELEMENT_DateTimeEdit ||
                           eUIType == XFA_ELEMENT_NumericEdit ||
                           eUIType == XFA_ELEMENT_TextEdit)) {
           CXFA_Node* pUINode = pEditNode->GetNodeItem(XFA_NODEITEM_Parent);
           if (pUINode) {
             pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                                  eValue, pUINode,
                                  pUINode->GetNodeItem(XFA_NODEITEM_Parent));
           }
         }
       } break;
       case XFA_ELEMENT_Button:
       case XFA_ELEMENT_Barcode:
       case XFA_ELEMENT_ChoiceList:
       case XFA_ELEMENT_DateTimeEdit:
       case XFA_ELEMENT_NumericEdit:
       case XFA_ELEMENT_PasswordEdit:
       case XFA_ELEMENT_TextEdit: {
-        CXFA_Node* pUINode = this->GetNodeItem(XFA_NODEITEM_Parent);
+        CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pUINode) {
           pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                                eValue, pUINode,
                                pUINode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       } break;
       case XFA_ELEMENT_CheckButton: {
         bNeedFindContainer = TRUE;
-        CXFA_Node* pUINode = this->GetNodeItem(XFA_NODEITEM_Parent);
+        CXFA_Node* pUINode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pUINode) {
           pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                                eValue, pUINode,
                                pUINode->GetNodeItem(XFA_NODEITEM_Parent));
         }
       } break;
       case XFA_ELEMENT_Keep:
       case XFA_ELEMENT_Bookend:
       case XFA_ELEMENT_Break:
       case XFA_ELEMENT_BreakAfter:
       case XFA_ELEMENT_BreakBefore:
       case XFA_ELEMENT_Overflow:
         bNeedFindContainer = TRUE;
         break;
       case XFA_ELEMENT_Area:
       case XFA_ELEMENT_Draw:
       case XFA_ELEMENT_ExclGroup:
       case XFA_ELEMENT_Field:
       case XFA_ELEMENT_Subform:
       case XFA_ELEMENT_SubformSet:
         pLayoutPro->AddChangedContainer(this);
         pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute,
                              eValue, this, this);
         break;
       case XFA_ELEMENT_Sharptext:
       case XFA_ELEMENT_Sharpxml:
       case XFA_ELEMENT_SharpxHTML: {
-        CXFA_Node* pTextNode = this->GetNodeItem(XFA_NODEITEM_Parent);
+        CXFA_Node* pTextNode = GetNodeItem(XFA_NODEITEM_Parent);
         if (!pTextNode) {
           return;
         }
         CXFA_Node* pValueNode = pTextNode->GetNodeItem(XFA_NODEITEM_Parent);
         if (!pValueNode) {
           return;
         }
         XFA_ELEMENT eType = pValueNode->GetClassID();
         if (eType == XFA_ELEMENT_Value) {
           bNeedFindContainer = TRUE;
@@ skipping 41 matching lines @@
 }
 void CXFA_Node::Script_Attribute_String(FXJSE_HVALUE hValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString szValue;
     FXJSE_Value_ToUTF8String(hValue, szValue);
     CFX_WideString wsValue =
         CFX_WideString::FromUTF8(szValue, szValue.GetLength());
     SetAttribute(eAttribute, wsValue, TRUE);
-    if (eAttribute == XFA_ATTRIBUTE_Use &&
-        this->GetClassID() == XFA_ELEMENT_Desc) {
+    if (eAttribute == XFA_ATTRIBUTE_Use && GetClassID() == XFA_ELEMENT_Desc) {
       CFX_WideString wsUseVal = wsValue, wsID, wsSOM;
       CXFA_Node* pTemplateNode =
           ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
       CXFA_Node* pProtoRoot =
           pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Subform)
               ->GetFirstChildByClass(XFA_ELEMENT_Proto);
       if (!wsUseVal.IsEmpty()) {
         if (wsUseVal[0] == '#') {
           wsID = CFX_WideString((const FX_WCHAR*)wsUseVal + 1,
                                 wsUseVal.GetLength() - 1);
@@ skipping 175 matching lines @@
     CFX_ByteString newValue;
     if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
       FXJSE_Value_ToUTF8String(hValue, newValue);
     }
     CFX_WideString wsNewValue =
         CFX_WideString::FromUTF8(newValue, newValue.GetLength());
     CFX_WideString wsFormatValue(wsNewValue);
     CXFA_WidgetData* pContainerWidgetData = NULL;
     if (GetPacketID() == XFA_XDPPACKET_Datasets) {
       CXFA_NodeArray formNodes;
-      this->GetBindItems(formNodes);
+      GetBindItems(formNodes);
       CFX_WideString wsPicture;
       for (int32_t i = 0; i < formNodes.GetSize(); i++) {
         CXFA_Node* pFormNode = formNodes.GetAt(i);
         if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
           continue;
         }
         pContainerWidgetData = pFormNode->GetContainerWidgetData();
         if (pContainerWidgetData) {
           pContainerWidgetData->GetPictureContent(wsPicture,
                                                   XFA_VALUEPICTURE_DataBind);
@@ skipping 870 matching lines @@
       }
     }
   } else {
     FXJSE_Value_SetInteger(hValue, Subform_and_SubformSet_InstanceIndex());
   }
 }
 void CXFA_Node::Script_Subform_InstanceManager(FXJSE_HVALUE hValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
-    CFX_WideStringC wsName = this->GetCData(XFA_ATTRIBUTE_Name);
+    CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
     CXFA_Node* pInstanceMgr = NULL;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling);
          pNode != NULL; pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       if (pNode->GetClassID() == XFA_ELEMENT_InstanceManager) {
         CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' &&
             wsInstMgrName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
         }
         break;
       }
     }
     if (pInstanceMgr) {
       FXJSE_Value_Set(
           hValue,
           m_pDocument->GetScriptContext()->GetJSValueFromMap(pInstanceMgr));
     } else {
       FXJSE_Value_SetNull(hValue);
     }
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Node::Script_Subform_Locale(FXJSE_HVALUE hValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString bsLocaleName;
     FXJSE_Value_ToUTF8String(hValue, bsLocaleName);
-    this->SetCData(
-        XFA_ATTRIBUTE_Locale,
-        CFX_WideString::FromUTF8(bsLocaleName, bsLocaleName.GetLength()), TRUE,
-        TRUE);
+    SetCData(XFA_ATTRIBUTE_Locale,
+             CFX_WideString::FromUTF8(bsLocaleName, bsLocaleName.GetLength()),
+             TRUE, TRUE);
   } else {
     CFX_WideString wsLocaleName;
     GetLocaleName(wsLocaleName);
     FXJSE_Value_SetUTF8String(
         hValue, FX_UTF8Encode(wsLocaleName, wsLocaleName.GetLength()));
   }
 }
 void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
@@ skipping 680 matching lines @@
   }
   if ((iMax >= 0) && (iDesired > iMax)) {
     ThrowScriptErrorMessage(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return 2;
   }
   int32_t iCount = XFA_ScriptInstanceManager_GetCount(this);
   if (iDesired == iCount) {
     return 0;
   }
   if (iDesired < iCount) {
-    CFX_WideStringC wsInstManagerName = this->GetCData(XFA_ATTRIBUTE_Name);
+    CFX_WideStringC wsInstManagerName = GetCData(XFA_ATTRIBUTE_Name);
     CFX_WideString wsInstanceName = wsInstManagerName.IsEmpty()
                                         ? wsInstManagerName
                                         : wsInstManagerName.Mid(1);
     FX_DWORD dInstanceNameHash =
         wsInstanceName.IsEmpty() ? 0 : FX_HashCode_String_GetW(
                                            wsInstanceName,
                                            wsInstanceName.GetLength());
     CXFA_Node* pPrevSibling =
         (iDesired == 0) ? this
                         : XFA_ScriptInstanceManager_GetItem(this, iDesired - 1);
@@ skipping 667 matching lines @@
       FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
       switch (eXMLType) {
         case FDE_XMLNODE_Element:
           if (IsAttributeInXML()) {
             ((IFDE_XMLElement*)m_pXMLNode)
                 ->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsValue);
           } else {
             FX_BOOL bDeleteChildren = TRUE;
             if (GetPacketID() == XFA_XDPPACKET_Datasets) {
               for (CXFA_Node* pChildDataNode =
-                       this->GetNodeItem(XFA_NODEITEM_FirstChild);
+                       GetNodeItem(XFA_NODEITEM_FirstChild);
                    pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(
                                        XFA_NODEITEM_NextSibling)) {
                 CXFA_NodeArray formNodes;
                 if (pChildDataNode->GetBindItems(formNodes) > 0) {
                   bDeleteChildren = FALSE;
                   break;
                 }
               }
             }
             if (bDeleteChildren) {
@@ skipping 39 matching lines @@
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
           ((IFDE_XMLElement*)m_pXMLNode)
               ->SetString(GetCData(XFA_ATTRIBUTE_QualifiedName), wsXMLValue);
         } else {
           FX_BOOL bDeleteChildren = TRUE;
           if (GetPacketID() == XFA_XDPPACKET_Datasets) {
             for (CXFA_Node* pChildDataNode =
-                     this->GetNodeItem(XFA_NODEITEM_FirstChild);
+                     GetNodeItem(XFA_NODEITEM_FirstChild);
                  pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(
                                      XFA_NODEITEM_NextSibling)) {
               CXFA_NodeArray formNodes;
               if (pChildDataNode->GetBindItems(formNodes) > 0) {
                 bDeleteChildren = FALSE;
                 break;
               }
             }
           }
           if (bDeleteChildren) {
@@ skipping 436 matching lines @@
     case XFA_XDPPACKET_SourceSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet));
     case XFA_XDPPACKET_Xdc:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
     default:
       return this;
   }
 }
 FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
   wsNamespace.Empty();
-  if (this->GetObjectType() == XFA_OBJECTTYPE_ModelNode ||
-      this->GetClassID() == XFA_ELEMENT_Packet) {
-    IFDE_XMLNode* pXMLNode = this->GetXMLMappingNode();
+  if (GetObjectType() == XFA_OBJECTTYPE_ModelNode ||
+      GetClassID() == XFA_ELEMENT_Packet) {
+    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return FALSE;
     }
     ((IFDE_XMLElement*)pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
-  } else if (this->GetPacketID() == XFA_XDPPACKET_Datasets) {
-    IFDE_XMLNode* pXMLNode = this->GetXMLMappingNode();
+  } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
+    IFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode) {
       return FALSE;
     }
     if (pXMLNode->GetType() != FDE_XMLNODE_Element) {
       return TRUE;
     }
-    if (this->GetClassID() == XFA_ELEMENT_DataValue &&
-        this->GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) {
+    if (GetClassID() == XFA_ELEMENT_DataValue &&
+        GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) {
       return XFA_FDEExtension_ResolveNamespaceQualifier(
-          (IFDE_XMLElement*)pXMLNode,
-          this->GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace);
+          (IFDE_XMLElement*)pXMLNode, GetCData(XFA_ATTRIBUTE_QualifiedName),
+          wsNamespace);
     }
     ((IFDE_XMLElement*)pXMLNode)->GetNamespaceURI(wsNamespace);
     return TRUE;
   } else {
     CXFA_Node* pModelNode = GetModelNode();
     return pModelNode->TryNamespace(wsNamespace);
   }
 }
 CXFA_Node* CXFA_Node::GetProperty(int32_t index,
                                   XFA_ELEMENT eProperty,
@@ skipping 29 matching lines @@
     }
   }
   IXFA_ObjFactory* pFactory = m_pDocument->GetParser()->GetFactory();
   const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(dwPacket);
   CXFA_Node* pNewNode;
   for (; iCount <= index; iCount++) {
     pNewNode = pFactory->CreateNode(pPacket, eProperty);
     if (!pNewNode) {
       return NULL;
     }
-    this->InsertChild(pNewNode, NULL);
+    InsertChild(pNewNode, nullptr);
     pNewNode->SetFlag(XFA_NODEFLAG_Initialized);
   }
   return pNewNode;
 }
 int32_t CXFA_Node::CountChildren(XFA_ELEMENT eElement, FX_BOOL bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eElement || eElement == XFA_ELEMENT_UNKNOWN) {
       if (bOnlyChild) {
@@ skipping 164 matching lines @@
                    m_pXMLNode->GetType() == FDE_XMLNODE_Element);
       if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) {
         IFDE_XMLElement* pXMLElement = (IFDE_XMLElement*)(pNode->m_pXMLNode);
         CFX_WideStringC wsAttributeName =
             pNode->GetCData(XFA_ATTRIBUTE_QualifiedName);
         pXMLElement->RemoveAttribute(wsAttributeName.GetPtr());
       }
       CFX_WideString wsName;
       pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
       IFDE_XMLElement* pNewXMLElement = IFDE_XMLElement::Create(wsName);
-      CFX_WideStringC wsValue = this->GetCData(XFA_ATTRIBUTE_Value);
+      CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pNewXMLElement->SetTextData(wsValue);
       }
       pNode->m_pXMLNode = pNewXMLElement;
       pNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       m_pXMLNode->RemoveChildNode(pNode->m_pXMLNode);
     }
     pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
   }
@@ skipping 250 matching lines @@
   return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets ||
                         GetClassID() == XFA_ELEMENT_Xfa);
 }
 XFA_LPMAPMODULEDATA CXFA_Node::GetMapModuleData(FX_BOOL bCreateNew) {
   if (!m_pMapModuleData && bCreateNew) {
     m_pMapModuleData = new XFA_MAPMODULEDATA;
   }
   return m_pMapModuleData;
 }
 void CXFA_Node::SetMapModuleValue(void* pKey, void* pValue) {
-  XFA_LPMAPMODULEDATA pMoudle = this->GetMapModuleData(TRUE);
-  if (!pMoudle) {
-    return;
-  }
-  pMoudle->m_ValueMap.SetAt(pKey, pValue);
+  XFA_LPMAPMODULEDATA pModule = GetMapModuleData(TRUE);
+  if (pModule)
+    pModule->m_ValueMap.SetAt(pKey, pValue);
 }
 FX_BOOL CXFA_Node::GetMapModuleValue(void* pKey, void*& pValue) {
   CXFA_Node* pNode = this;
   while (pNode) {
-    XFA_LPMAPMODULEDATA pMoudle = pNode->GetMapModuleData(FALSE);
-    if (pMoudle && pMoudle->m_ValueMap.Lookup(pKey, pValue)) {
+    XFA_LPMAPMODULEDATA pModule = pNode->GetMapModuleData(FALSE);
+    if (pModule && pModule->m_ValueMap.Lookup(pKey, pValue)) {
       return TRUE;
     }
     pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets
                 ? pNode->GetTemplateNode()
                 : NULL;
   }
   return FALSE;
 }
 void CXFA_Node::SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue) {
   SetMapModuleBuffer(pKey, (void*)wsValue.GetPtr(),
                      wsValue.GetLength() * sizeof(FX_WCHAR));
 }
 FX_BOOL CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) {
   void* pValue;
   int32_t iBytes;
   if (!GetMapModuleBuffer(pKey, pValue, iBytes)) {
     return FALSE;
   }
   wsValue = CFX_WideStringC((const FX_WCHAR*)pValue, iBytes / sizeof(FX_WCHAR));
   return TRUE;
 }
 void CXFA_Node::SetMapModuleBuffer(
     void* pKey,
     void* pValue,
     int32_t iBytes,
     XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
-  XFA_LPMAPMODULEDATA pMoudle = this->GetMapModuleData(TRUE);
-  if (!pMoudle) {
+  XFA_LPMAPMODULEDATA pModule = GetMapModuleData(TRUE);
+  if (!pModule)
     return;
-  }
-  XFA_LPMAPDATABLOCK& pBuffer = pMoudle->m_BufferMap[pKey];
+
+  XFA_LPMAPDATABLOCK& pBuffer = pModule->m_BufferMap[pKey];
   if (pBuffer == NULL) {
     pBuffer = (XFA_LPMAPDATABLOCK)FX_Alloc(uint8_t,
                                            sizeof(XFA_MAPDATABLOCK) + iBytes);
   } else if (pBuffer->iBytes != iBytes) {
     if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
       pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
     }
     pBuffer = (XFA_LPMAPDATABLOCK)FX_Realloc(uint8_t, pBuffer,
                                              sizeof(XFA_MAPDATABLOCK) + iBytes);
   } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
     pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
   }
   if (pBuffer == NULL) {
     return;
   }
   pBuffer->pCallbackInfo = pCallbackInfo;
   pBuffer->iBytes = iBytes;
   FXSYS_memcpy(pBuffer->GetData(), pValue, iBytes);
 }
 FX_BOOL CXFA_Node::GetMapModuleBuffer(void* pKey,
                                       void*& pValue,
                                       int32_t& iBytes,
                                       FX_BOOL bProtoAlso) {
   XFA_LPMAPDATABLOCK pBuffer = NULL;
   CXFA_Node* pNode = this;
   while (pNode) {
-    XFA_LPMAPMODULEDATA pMoudle = pNode->GetMapModuleData(FALSE);
-    if (pMoudle && pMoudle->m_BufferMap.Lookup(pKey, pBuffer)) {
+    XFA_LPMAPMODULEDATA pModule = pNode->GetMapModuleData(FALSE);
+    if (pModule && pModule->m_BufferMap.Lookup(pKey, pBuffer)) {
       break;
     }
     pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
                 ? pNode->GetTemplateNode()
                 : NULL;
   }
   if (pBuffer == NULL) {
     return FALSE;
   }
   pValue = pBuffer->GetData();
   iBytes = pBuffer->iBytes;
   return TRUE;
 }
 FX_BOOL CXFA_Node::HasMapModuleKey(void* pKey, FX_BOOL bProtoAlso) {
   CXFA_Node* pNode = this;
   while (pNode) {
     void* pVal;
-    XFA_LPMAPMODULEDATA pMoudle = pNode->GetMapModuleData(FALSE);
-    if (pMoudle &&
-        (pMoudle->m_ValueMap.Lookup(pKey, pVal) ||
-         pMoudle->m_BufferMap.Lookup(pKey, (XFA_LPMAPDATABLOCK&)pVal))) {
+    XFA_LPMAPMODULEDATA pModule = pNode->GetMapModuleData(FALSE);
+    if (pModule &&
+        (pModule->m_ValueMap.Lookup(pKey, pVal) ||
+         pModule->m_BufferMap.Lookup(pKey, (XFA_LPMAPDATABLOCK&)pVal))) {
       return TRUE;
     }
     pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
                 ? pNode->GetTemplateNode()
                 : NULL;
   }
   return FALSE;
 }
 void CXFA_Node::RemoveMapModuleKey(void* pKey) {
-  XFA_LPMAPMODULEDATA pMoudle = this->GetMapModuleData(FALSE);
-  if (!pMoudle) {
+  XFA_LPMAPMODULEDATA pModule = GetMapModuleData(FALSE);
+  if (!pModule)
     return;
-  }
+
   if (pKey) {
     XFA_LPMAPDATABLOCK pBuffer = NULL;
-    pMoudle->m_BufferMap.Lookup(pKey, pBuffer);
+    pModule->m_BufferMap.Lookup(pKey, pBuffer);
     if (pBuffer) {
       if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
         pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
       }
       FX_Free(pBuffer);
     }
-    pMoudle->m_BufferMap.RemoveKey(pKey);
-    pMoudle->m_ValueMap.RemoveKey(pKey);
+    pModule->m_BufferMap.RemoveKey(pKey);
+    pModule->m_ValueMap.RemoveKey(pKey);
   } else {
     XFA_LPMAPDATABLOCK pBuffer;
-    FX_POSITION posBuffer = pMoudle->m_BufferMap.GetStartPosition();
+    FX_POSITION posBuffer = pModule->m_BufferMap.GetStartPosition();
     while (posBuffer) {
-      pMoudle->m_BufferMap.GetNextAssoc(posBuffer, pKey, pBuffer);
+      pModule->m_BufferMap.GetNextAssoc(posBuffer, pKey, pBuffer);
       if (pBuffer) {
         if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
           pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
         }
         FX_Free(pBuffer);
       }
     }
-    pMoudle->m_BufferMap.RemoveAll();
-    pMoudle->m_ValueMap.RemoveAll();
-    if (pMoudle) {
-      delete pMoudle;
-      pMoudle = NULL;
-    }
+    pModule->m_BufferMap.RemoveAll();
+    pModule->m_ValueMap.RemoveAll();
+    delete pModule;
   }
 }
 void CXFA_Node::MergeAllData(void* pDstModule, FX_BOOL bUseSrcAttr) {
   XFA_LPMAPMODULEDATA pDstModuleData =
       static_cast<CXFA_Node*>(pDstModule)->GetMapModuleData(TRUE);
   if (!pDstModuleData) {
     return;
   }
-  XFA_LPMAPMODULEDATA pSrcModuleData = this->GetMapModuleData(FALSE);
+  XFA_LPMAPMODULEDATA pSrcModuleData = GetMapModuleData(FALSE);
   if (!pSrcModuleData) {
     return;
   }
   FX_POSITION psValue = pSrcModuleData->m_ValueMap.GetStartPosition();
   while (psValue) {
     void* pKey;
     void* pValue;
     pSrcModuleData->m_ValueMap.GetNextAssoc(psValue, pKey, pValue);
     if (bUseSrcAttr || !pDstModuleData->m_ValueMap.GetValueAt(pKey)) {
       pDstModuleData->m_ValueMap.SetAt(pKey, pValue);
@@ skipping 40 matching lines @@
   }
 }
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pDstModule, void* pKey) {
   if (!pDstModule) {
     return;
   }
   FX_BOOL bNeedMove = TRUE;
   if (!pKey) {
     bNeedMove = FALSE;
   }
-  if (pDstModule->GetClassID() != this->GetClassID()) {
+  if (pDstModule->GetClassID() != GetClassID()) {
     bNeedMove = FALSE;
   }
   XFA_LPMAPMODULEDATA pSrcModuleData = NULL;
   XFA_LPMAPMODULEDATA pDstModuleData = NULL;
   if (bNeedMove) {
-    pSrcModuleData = this->GetMapModuleData(FALSE);
+    pSrcModuleData = GetMapModuleData(FALSE);
     if (!pSrcModuleData) {
       bNeedMove = FALSE;
     }
     pDstModuleData = pDstModule->GetMapModuleData(TRUE);
     if (!pDstModuleData) {
       bNeedMove = FALSE;
     }
   }
   if (bNeedMove) {
     void* pBufferBlockData = pSrcModuleData->m_BufferMap.GetValueAt(pKey);
@@ skipping 199 matching lines @@
   return m_pAttachNode->InsertChild(pNewNode, pBeforeNode);
 }
 FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) {
   return m_pAttachNode->RemoveChild(pNode);
 }
 CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) {
   return m_pAttachNode->GetChild(
       iIndex, XFA_ELEMENT_UNKNOWN,
       m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform);
 }