Simplify XFA event handling.

xfa/fxfa/parser/xfa_parser_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_parser_imp.h"
 
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
@@ skipping 157 matching lines @@
           CFDE_XMLElement* child = static_cast<CFDE_XMLElement*>(pXMLChild);
           child->GetLocalTagName(wsNodeStr);
           pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
           CFX_WideString wsChildValue;
           XFA_GetPlainTextFromRichText(child, wsChildValue);
           if (!wsChildValue.IsEmpty())
             pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsChildValue);
 
           pXFANode->InsertChild(pXFAChild);
           pXFAChild->SetXMLMappingNode(pXMLChild);
-          pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+          pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
           break;
         }
       }
       m_pRootNode = pXFANode;
     } else {
       m_pRootNode = DataLoader(pXFANode, pXMLNode, TRUE);
     }
   } else if (pXFANode->GetObjectType() == XFA_OBJECTTYPE_ContentNode) {
     ParseContentNode(pXFANode, pXMLNode, ePacketID);
     m_pRootNode = pXFANode;
@@ skipping 498 matching lines @@
       return NULL;
     }
     CFX_WideString wsLocalName;
     static_cast<CFDE_XMLElement*>(pDataXMLNode)->GetLocalTagName(wsLocalName);
     pNode->SetCData(XFA_ATTRIBUTE_Name, wsLocalName);
     if (!DataLoader(pNode, pDataXMLNode, TRUE)) {
       return NULL;
     }
     pNode->SetXMLMappingNode(pDataXMLNode);
     if (pDataXMLNode != pXMLDocumentNode) {
-      pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
+      pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, false);
     }
     return pNode;
   }
   return NULL;
 }
 CXFA_Node* CXFA_SimpleParser::ParseAsXDPPacket_LocaleConnectionSourceSet(
     CFDE_XMLNode* pXMLDocumentNode,
     XFA_XDPPACKET ePacketID) {
   CXFA_Node* pNode = NULL;
   if (ePacketID == XFA_XDPPACKET_LocaleSet) {
@@ skipping 430 matching lines @@
               return;
             }
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_Name, wsAttrName);
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_QualifiedName,
                                    wsAttrQualifiedName);
             pXFAMetaData->SetCData(XFA_ATTRIBUTE_Value, wsAttrValue);
             pXFAMetaData->SetEnum(XFA_ATTRIBUTE_Contains,
                                   XFA_ATTRIBUTEENUM_MetaData);
             pXFAChild->InsertChild(pXFAMetaData);
             pXFAMetaData->SetXMLMappingNode(pXMLElement);
-            pXFAMetaData->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+            pXFAMetaData->SetFlag(XFA_NODEFLAG_Initialized, false);
           }
           if (!bNeedValue) {
             CFX_WideString wsNilName = FX_WSTRC(L"xsi:nil");
             pXMLElement->RemoveAttribute(wsNilName.c_str());
           }
         }
         pXFANode->InsertChild(pXFAChild);
         if (eNodeType == XFA_ELEMENT_DataGroup) {
           ParseDataGroup(pXFAChild, pXMLElement, ePacketID);
         } else {
           if (bNeedValue) {
             ParseDataValue(pXFAChild, pXMLChild, XFA_XDPPACKET_Datasets);
           }
         }
         pXFAChild->SetXMLMappingNode(pXMLElement);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
       }
         continue;
       case FDE_XMLNODE_CharData: {
         CFDE_XMLCharData* pXMLCharData =
             static_cast<CFDE_XMLCharData*>(pXMLChild);
         CFX_WideString wsCharData;
         pXMLCharData->GetCharData(wsCharData);
         if (XFA_FDEExtension_IsStringAllWhitespace(wsCharData)) {
           continue;
         }
         CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
                                                       XFA_ELEMENT_DataValue);
         if (pXFAChild == NULL) {
           return;
         }
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCharData);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLCharData);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
       }
         continue;
       case FDE_XMLNODE_Text: {
         CFDE_XMLText* pXMLText = static_cast<CFDE_XMLText*>(pXMLChild);
         CFX_WideString wsText;
         pXMLText->GetText(wsText);
         if (XFA_FDEExtension_IsStringAllWhitespace(wsText)) {
           continue;
         }
         CXFA_Node* pXFAChild = m_pFactory->CreateNode(XFA_XDPPACKET_Datasets,
                                                       XFA_ELEMENT_DataValue);
         if (pXFAChild == NULL) {
           return;
         }
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsText);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLText);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
       }
         continue;
       case FDE_XMLNODE_Instruction:
         continue;
       default:
         continue;
     }
   }
 }
 
@@ skipping 40 matching lines @@
         if (!wsCurValue.IsEmpty()) {
           CXFA_Node* pXFAChild =
               m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
           if (!pXFAChild)
             return;
 
           pXFAChild->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L""));
           pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue);
           pXFANode->InsertChild(pXFAChild);
           pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
-          pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+          pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
           wsValueTextBuf << wsCurValue;
           wsCurValueTextBuf.Clear();
         }
         pXMLCurValueNode = nullptr;
       }
       CXFA_Node* pXFAChild =
           m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
       if (!pXFAChild)
         return;
 
       CFX_WideString wsNodeStr;
       static_cast<CFDE_XMLElement*>(pXMLChild)->GetLocalTagName(wsNodeStr);
       pXFAChild->SetCData(XFA_ATTRIBUTE_Name, wsNodeStr);
       ParseDataValue(pXFAChild, pXMLChild, ePacketID);
       pXFANode->InsertChild(pXFAChild);
       pXFAChild->SetXMLMappingNode(pXMLChild);
-      pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+      pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
       CFX_WideStringC wsCurValue = pXFAChild->GetCData(XFA_ATTRIBUTE_Value);
       wsValueTextBuf << wsCurValue;
     }
   }
   if (pXMLCurValueNode) {
     CFX_WideStringC wsCurValue = wsCurValueTextBuf.GetWideString();
     if (!wsCurValue.IsEmpty()) {
       if (bMarkAsCompound) {
         CXFA_Node* pXFAChild =
             m_pFactory->CreateNode(ePacketID, XFA_ELEMENT_DataValue);
         if (!pXFAChild)
           return;
 
         pXFAChild->SetCData(XFA_ATTRIBUTE_Name, FX_WSTRC(L""));
         pXFAChild->SetCData(XFA_ATTRIBUTE_Value, wsCurValue);
         pXFANode->InsertChild(pXFAChild);
         pXFAChild->SetXMLMappingNode(pXMLCurValueNode);
-        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, TRUE, FALSE);
+        pXFAChild->SetFlag(XFA_NODEFLAG_Initialized, false);
       }
       wsValueTextBuf << wsCurValue;
       wsCurValueTextBuf.Clear();
     }
     pXMLCurValueNode = nullptr;
   }
   CFX_WideStringC wsNodeValue = wsValueTextBuf.GetWideString();
   pXFANode->SetCData(XFA_ATTRIBUTE_Value, wsNodeValue);
 }
 
@@ skipping 249 matching lines @@
     }
     if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return (m_syntaxParserResult == FDE_XmlSyntaxResult::Error ||
           m_NodeStack.GetSize() != 1)
              ? -1
              : m_pParser->GetStatus();
 }