Remove IXFA_Parser, cleanup XFA parser code.

xfa/fxfa/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/fxfa/parser/xfa_object.h"
 
 #include <memory>
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "fxjse/include/cfxjse_arguments.h"
 #include "third_party/base/stl_util.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/crt/fgas_system.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/parser/cxfa_occur.h"
 #include "xfa/fxfa/parser/xfa_basic_imp.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_document_layout_imp.h"
 #include "xfa/fxfa/parser/xfa_localemgr.h"
-#include "xfa/fxfa/parser/xfa_parser.h"
 #include "xfa/fxfa/parser/xfa_parser_imp.h"
 #include "xfa/fxfa/parser/xfa_script.h"
 #include "xfa/fxfa/parser/xfa_script_imp.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
 
 namespace {
 
 void XFA_DeleteWideString(void* pData) {
   delete static_cast<CFX_WideString*>(pData);
 }
@@ skipping 94 matching lines @@
     CXFA_Node* pNext = pNode->m_pNext;
     pNode->m_pParent = nullptr;
     delete pNode;
     pNode = pNext;
   }
   if (m_pXMLNode && IsOwnXMLNode())
     m_pXMLNode->Release();
 }
 
 CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive) {
-  CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
-  CXFA_Node* pClone = pFactory->CreateNode(m_ePacket, m_elementType);
+  CXFA_Node* pClone = m_pDocument->CreateNode(m_ePacket, m_elementType);
   if (!pClone)
     return nullptr;
 
   MergeAllData(pClone);
   pClone->UpdateNameHash();
   if (IsNeedSavingXMLNode()) {
     CFDE_XMLNode* pCloneXML = nullptr;
     if (IsAttributeInXML()) {
       CFX_WideString wsName;
       GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
@@ skipping 137 matching lines @@
       pChild = pChild->m_pNext;
     }
     if (bFilterOneOfProperties && nodes.GetSize() < 1) {
       int32_t iProperties = 0;
       const XFA_PROPERTY* pProperty =
           XFA_GetElementProperties(GetElementType(), iProperties);
       if (!pProperty || iProperties < 1)
         return 0;
       for (int32_t i = 0; i < iProperties; i++) {
         if (pProperty[i].uFlags & XFA_PROPERTYFLAG_DefaultOneOf) {
-          CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
           const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(GetPacketID());
           CXFA_Node* pNewNode =
-              pFactory->CreateNode(pPacket, pProperty[i].eName);
+              m_pDocument->CreateNode(pPacket, pProperty[i].eName);
           if (!pNewNode)
             break;
           InsertChild(pNewNode, nullptr);
           pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
           nodes.Add(pNewNode);
           break;
         }
       }
     }
   }
   return nodes.GetSize();
 }
 
 CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_Element eType,
                                            uint32_t dwFlags) {
-  CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
-  CXFA_Node* pNode = pFactory->CreateNode(m_ePacket, eType);
+  CXFA_Node* pNode = m_pDocument->CreateNode(m_ePacket, eType);
   pNode->SetFlag(dwFlags, true);
   return pNode;
 }
 
 CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) {
   ASSERT(m_ePacket == XFA_XDPPACKET_Template);
-  CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
-  CXFA_Node* pClone = pFactory->CreateNode(XFA_XDPPACKET_Form, m_elementType);
+  CXFA_Node* pClone =
+      m_pDocument->CreateNode(XFA_XDPPACKET_Form, m_elementType);
   if (!pClone)
     return nullptr;
 
   pClone->SetTemplateNode(this);
   pClone->UpdateNameHash();
   pClone->SetXMLMappingNode(GetXMLMappingNode());
   if (bRecursive) {
     for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild;
          pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pClone->InsertChild(pChild->CloneTemplateToForm(bRecursive));
@@ skipping 594 matching lines @@
   bool bIgnoreRoot = true;
   bool bOverwrite = 0;
   wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   if (wsExpression.IsEmpty())
     return;
   if (iLength >= 2)
     bIgnoreRoot = !!pArguments->GetInt32(1);
   if (iLength >= 3)
     bOverwrite = !!pArguments->GetInt32(2);
-  std::unique_ptr<IXFA_Parser, ReleaseDeleter<IXFA_Parser>> pParser(
-      IXFA_Parser::Create(m_pDocument));
+  std::unique_ptr<CXFA_SimpleParser> pParser(
+      new CXFA_SimpleParser(m_pDocument, false));
   if (!pParser)
     return;
   CFDE_XMLNode* pXMLNode = nullptr;
   int32_t iParserStatus =
       pParser->ParseXMLData(wsExpression, pXMLNode, nullptr);
   if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode)
     return;
   if (bIgnoreRoot &&
       (pXMLNode->GetType() != FDE_XMLNODE_Element ||
        XFA_RecognizeRichText(static_cast<CFDE_XMLElement*>(pXMLNode)))) {
@@ skipping 305 matching lines @@
   }
 }
 
 void CXFA_Node::Script_Attribute_SendAttributeChangeMessage(
     XFA_ATTRIBUTE eAttribute,
     FX_BOOL bScriptModify) {
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro)
     return;
 
-  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify)
     return;
 
   uint32_t dwPacket = GetPacketID();
   if (!(dwPacket & XFA_XDPPACKET_Form)) {
     pNotify->OnValueChanged(this, eAttribute, this, this);
     return;
   }
 
   bool bNeedFindContainer = false;
@@ skipping 255 matching lines @@
       case XFA_SOM_FormatMessage:
         validate.SetFormatMessageText(pValue->ToWideString());
         break;
       case XFA_SOM_MandatoryMessage:
         validate.SetNullMessageText(pValue->ToWideString());
         break;
       default:
         break;
     }
     if (!bNew) {
-      CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+      CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
       if (!pNotify) {
         return;
       }
       pNotify->AddCalcValidate(this);
     }
   } else {
     CFX_WideString wsMessage;
     switch (iMessageType) {
       case XFA_SOM_ValidationMessage:
         validate.GetScriptMessageText(wsMessage);
@@ skipping 543 matching lines @@
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, FALSE, FALSE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
 void CXFA_Node::Script_Field_DeleteItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
@@ skipping 66 matching lines @@
   }
   int32_t iIndex = pArguments->GetInt32(0);
   FX_BOOL bValue = pWidgetData->GetItemState(iIndex);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     pValue->SetBoolean(bValue);
 }
 void CXFA_Node::Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, FALSE, FALSE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 void CXFA_Node::Script_Field_SetItems(CFXJSE_Arguments* pArguments) {}
 void CXFA_Node::Script_Field_GetDisplayItem(CFXJSE_Arguments* pArguments) {
@@ skipping 57 matching lines @@
   }
   if (iLength >= 2) {
     CFX_ByteString bsValue = pArguments->GetUTF8String(1);
     wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
   }
   pWidgetData->InsertItem(wsLabel, wsValue, -1, TRUE);
 }
 void CXFA_Node::Script_Field_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       int32_t iRet =
           pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, FALSE, FALSE);
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
@@ skipping 68 matching lines @@
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   pArguments->GetReturnValue()->Assign(
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pReturnNode));
 }
 
 void CXFA_Node::Script_ExclGroup_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
 void CXFA_Node::Script_ExclGroup_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 void CXFA_Node::Script_ExclGroup_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
@@ skipping 41 matching lines @@
     CXFA_Node* pManagerNode = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       if (pNode->GetElementType() == XFA_Element::InstanceManager) {
         pManagerNode = pNode;
         break;
       }
     }
     if (pManagerNode) {
       pManagerNode->InstanceManager_MoveInstance(iTo, iFrom);
-      CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+      CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
       if (!pNotify) {
         return;
       }
       CXFA_Node* pToInstance =
           XFA_ScriptInstanceManager_GetItem(pManagerNode, iTo);
       if (pToInstance &&
           pToInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pToInstance);
       }
       CXFA_Node* pFromInstance =
@@ skipping 54 matching lines @@
     execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_Element::Subform);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 void CXFA_Node::Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
 void CXFA_Node::Script_Subform_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 void CXFA_Node::Script_Subform_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
@@ skipping 441 matching lines @@
 void CXFA_Node::Script_InstanceManager_MoveInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc != 2) {
     pArguments->GetReturnValue()->SetUndefined();
     return;
   }
   int32_t iFrom = pArguments->GetInt32(0);
   int32_t iTo = pArguments->GetInt32(1);
   InstanceManager_MoveInstance(iTo, iFrom);
-  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify) {
     return;
   }
   CXFA_Node* pToInstance = XFA_ScriptInstanceManager_GetItem(this, iTo);
   if (pToInstance && pToInstance->GetElementType() == XFA_Element::Subform) {
     pNotify->RunSubformIndexChange(pToInstance);
   }
   CXFA_Node* pFromInstance = XFA_ScriptInstanceManager_GetItem(this, iFrom);
   if (pFromInstance &&
       pFromInstance->GetElementType() == XFA_Element::Subform) {
@@ skipping 14 matching lines @@
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMin = nodeOccur.GetMin();
   if (iCount - 1 < iMin) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"min");
     return;
   }
   CXFA_Node* pRemoveInstance = XFA_ScriptInstanceManager_GetItem(this, iIndex);
   XFA_ScriptInstanceManager_RemoveItem(this, pRemoveInstance);
-  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (pNotify) {
     for (int32_t i = iIndex; i < iCount - 1; i++) {
       CXFA_Node* pSubformInstance = XFA_ScriptInstanceManager_GetItem(this, i);
       if (pSubformInstance &&
           pSubformInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pSubformInstance);
       }
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
@@ skipping 30 matching lines @@
   if (iMax >= 0 && iCount >= iMax) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return;
   }
   CXFA_Node* pNewInstance =
       XFA_ScriptInstanceManager_CreateInstance(this, fFlags);
   XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount,
                                        FALSE);
   pArguments->GetReturnValue()->Assign(
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
-  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->RunNodeInitialize(pNewInstance);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
@@ skipping 20 matching lines @@
   if (iMax >= 0 && iCount >= iMax) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return;
   }
   CXFA_Node* pNewInstance =
       XFA_ScriptInstanceManager_CreateInstance(this, bBind);
   XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iIndex, iCount,
                                        TRUE);
   pArguments->GetReturnValue()->Assign(
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
-  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->RunNodeInitialize(pNewInstance);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
@@ skipping 40 matching lines @@
         iCount--;
       }
     }
   } else if (iDesired > iCount) {
     while (iCount < iDesired) {
       CXFA_Node* pNewInstance =
           XFA_ScriptInstanceManager_CreateInstance(this, TRUE);
       XFA_ScriptInstanceManager_InsertItem(this, pNewInstance, iCount, iCount,
                                            FALSE);
       iCount++;
-      CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+      CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
       if (!pNotify) {
         return 0;
       }
       pNotify->RunNodeInitialize(pNewInstance);
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (pLayoutPro) {
     pLayoutPro->AddChangedContainer(
         ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
@@ skipping 71 matching lines @@
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     m_pDocument->DoDataRemerge(TRUE);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
   }
 }
 void CXFA_Node::Script_Form_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
 void CXFA_Node::Script_Form_Recalculate(CFXJSE_Arguments* pArguments) {
   CXFA_EventParam* pEventParam =
       m_pDocument->GetScriptContext()->GetEventParam();
   if (pEventParam->m_eType == XFA_EVENT_Calculate ||
       pEventParam->m_eType == XFA_EVENT_InitCalculate) {
     return;
   }
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     const bool bScriptFlags = pArguments->GetInt32(0) != 0;
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     if (bScriptFlags) {
       pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
       pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Ready, TRUE);
     } else {
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
   }
 }
 void CXFA_Node::Script_Form_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 void CXFA_Node::Script_Form_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       pArguments->GetReturnValue()->SetBoolean(FALSE);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
           (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
@@ skipping 1020 matching lines @@
 
   if (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf) {
     pNode = m_pChild;
     for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       const XFA_PROPERTY* pExistProperty =
           XFA_GetPropertyOfElement(eType, pNode->GetElementType(), dwPacket);
       if (pExistProperty && (pExistProperty->uFlags & XFA_PROPERTYFLAG_OneOf))
         return nullptr;
     }
   }
-  CXFA_Document* pFactory = m_pDocument->GetParser()->GetFactory();
+
   const XFA_PACKETINFO* pPacket = XFA_GetPacketByID(dwPacket);
   CXFA_Node* pNewNode = nullptr;
   for (; iCount <= index; iCount++) {
-    pNewNode = pFactory->CreateNode(pPacket, eProperty);
+    pNewNode = m_pDocument->CreateNode(pPacket, eProperty);
     if (!pNewNode)
       return nullptr;
     InsertChild(pNewNode, nullptr);
     pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   return pNewNode;
 }
 int32_t CXFA_Node::CountChildren(XFA_Element eType, FX_BOOL bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
@@ skipping 62 matching lines @@
     pNode->m_pNext = pPrev->m_pNext;
     pPrev->m_pNext = pNode;
     index = iCount;
   }
   if (!pNode->m_pNext) {
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
   ASSERT(!m_pLastChild->m_pNext);
   pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren);
-  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (pNotify)
     pNotify->OnChildAdded(this);
 
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index);
     pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode);
   }
   return index;
 }
@@ skipping 26 matching lines @@
     }
     pNode->m_pNext = pPrev->m_pNext;
     pPrev->m_pNext = pNode;
   }
   if (!pNode->m_pNext) {
     m_pLastChild = pNode;
   }
   ASSERT(m_pLastChild);
   ASSERT(!m_pLastChild->m_pNext);
   pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren);
-  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (pNotify)
     pNotify->OnChildAdded(this);
 
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex);
     pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode);
   }
   return TRUE;
 }
@@ skipping 158 matching lines @@
 bool CXFA_Node::HasFlag(XFA_NodeFlag dwFlag) const {
   if (m_uNodeFlags & dwFlag)
     return true;
   if (dwFlag == XFA_NodeFlag_HasRemovedChildren)
     return m_pParent && m_pParent->HasFlag(dwFlag);
   return false;
 }
 
 void CXFA_Node::SetFlag(uint32_t dwFlag, bool bNotify) {
   if (dwFlag == XFA_NodeFlag_Initialized && bNotify && !IsInitialized()) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (pNotify) {
       pNotify->OnNodeReady(this);
     }
   }
   m_uNodeFlags |= dwFlag;
 }
 
 void CXFA_Node::ClearFlag(uint32_t dwFlag) {
   m_uNodeFlags &= ~dwFlag;
 }
 
 FX_BOOL CXFA_Node::IsAttributeInXML() {
   return GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData;
 }
 
 void CXFA_Node::OnRemoved(bool bNotify) {
   if (!bNotify)
     return;
 
-  CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+  CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (pNotify)
     pNotify->OnChildRemoved();
 }
 
 void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr, bool bNotify) {
   if (bNotify && IsInitialized()) {
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (pNotify) {
       pNotify->OnValueChanging(this, eAttr);
     }
   }
 }
 
 void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr,
                           bool bNotify,
                           FX_BOOL bScriptModify) {
   if (bNotify && IsInitialized()) {
     Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify);
   }
 }
 
 int32_t CXFA_Node::execSingleEventByName(const CFX_WideStringC& wsEventName,
                                          XFA_Element eType) {
   int32_t iRet = XFA_EVENTERROR_NotExist;
   const XFA_ExecEventParaInfo* eventParaInfo =
       GetEventParaInfoByName(wsEventName);
   if (eventParaInfo) {
     uint32_t validFlags = eventParaInfo->m_validFlags;
-    CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
+    CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return iRet;
     }
     if (validFlags == 1) {
       iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType);
     } else if (validFlags == 2) {
       iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
                                            FALSE, FALSE);
     } else if (validFlags == 3) {
       if (eType == XFA_Element::Subform) {
@@ skipping 508 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->GetElementType() == XFA_Element::Subform);
 }