Remove default parameters from CXFA_SimpleParser.

xfa/fxfa/parser/cxfa_simple_parser.cpp

 // Copyright 2016 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/cxfa_simple_parser.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
@@ skipping 369 matching lines @@
         }
       }
       m_pRootNode = pXFANode;
     } else {
       m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE);
     }
   } else if (pXFANode->IsContentNode()) {
     ParseContentNode(pXFANode, pXMLNode, ePacketID);
     m_pRootNode = pXFANode;
   } else {
-    m_pRootNode = NormalLoader(pXFANode, pXMLNode, ePacketID);
+    m_pRootNode = NormalLoader(pXFANode, pXMLNode, ePacketID, TRUE);
   }
 }
 
 CXFA_Node* CXFA_SimpleParser::GetRootNode() const {
   return m_pRootNode;
 }
 
 CFDE_XMLDoc* CXFA_SimpleParser::GetXMLDoc() const {
   return m_pXMLDoc.get();
 }
@@ skipping 198 matching lines @@
                      XFA_GetPacketByIndex(XFA_PACKET_Config)->eFlags)) {
     return nullptr;
   }
   CXFA_Node* pNode =
       m_pFactory->CreateNode(XFA_XDPPACKET_Config, XFA_Element::Config);
   if (!pNode)
     return nullptr;
 
   pNode->SetCData(XFA_ATTRIBUTE_Name,
                   XFA_GetPacketByIndex(XFA_PACKET_Config)->pName);
-  if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID))
+  if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, TRUE))
     return nullptr;
 
   pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
 
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_TemplateForm(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = nullptr;
@@ skipping 12 matching lines @@
       if (m_bDocumentParser) {
         CFX_WideString wsNamespaceURI;
         CFDE_XMLElement* pXMLDocumentElement =
             static_cast<CFDE_XMLElement*>(pXMLDocumentNode);
         pXMLDocumentElement->GetNamespaceURI(wsNamespaceURI);
         if (wsNamespaceURI.IsEmpty())
           pXMLDocumentElement->GetString(L"xmlns:xfa", wsNamespaceURI);
 
         pNode->GetDocument()->RecognizeXFAVersionNumber(wsNamespaceURI);
       }
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID))
+      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, TRUE))
         return nullptr;
     }
   } else if (ePacketID == XFA_XDPPACKET_Form) {
     if (MatchNodeName(pXMLDocumentNode,
                       XFA_GetPacketByIndex(XFA_PACKET_Form)->pName,
                       XFA_GetPacketByIndex(XFA_PACKET_Form)->pURI,
                       XFA_GetPacketByIndex(XFA_PACKET_Form)->eFlags)) {
       CFDE_XMLElement* pXMLDocumentElement =
           static_cast<CFDE_XMLElement*>(pXMLDocumentNode);
       CFX_WideString wsChecksum;
@@ skipping 115 matching lines @@
                       XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName,
                       XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pURI,
                       XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_LocaleSet,
                                      XFA_Element::LocaleSet);
       if (!pNode)
         return nullptr;
 
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_LocaleSet)->pName);
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID))
+      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, TRUE))
         return nullptr;
     }
   } else if (ePacketID == XFA_XDPPACKET_ConnectionSet) {
     if (MatchNodeName(pXMLDocumentNode,
                       XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName,
                       XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pURI,
                       XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_ConnectionSet,
                                      XFA_Element::ConnectionSet);
       if (!pNode)
         return nullptr;
 
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_ConnectionSet)->pName);
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID))
+      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, TRUE))
         return nullptr;
     }
   } else if (ePacketID == XFA_XDPPACKET_SourceSet) {
     if (MatchNodeName(pXMLDocumentNode,
                       XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName,
                       XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pURI,
                       XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->eFlags)) {
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_SourceSet,
                                      XFA_Element::SourceSet);
       if (!pNode)
         return nullptr;
 
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_SourceSet)->pName);
-      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID))
+      if (!NormalLoader(pNode, pXMLDocumentNode, ePacketID, TRUE))
         return nullptr;
     }
   }
   if (pNode)
     pNode->SetXMLMappingNode(pXMLDocumentNode);
   return pNode;
 }
 
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_Xdc(
     CFDE_XMLNode* pXMLDocumentNode,
@@ skipping 481 matching lines @@
         pXFANode->GetDocument()->SetFlag(XFA_DOCFLAG_StrictScoping, TRUE);
       }
     }
   }
 }
 
 void CXFA_SimpleParser::CloseParser() {
   m_pXMLDoc.reset();
   m_pStream.reset();
 }