Remove FX_BOOL from xfa.

xfa/fxfa/app/xfa_ffdocview.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/xfa_ffdocview.h"
 
 #include "core/fxcrt/fx_ext.h"
 #include "xfa/fxfa/app/xfa_ffbarcode.h"
@@ skipping 34 matching lines @@
     XFA_ATTRIBUTEENUM_PostOpen,   XFA_ATTRIBUTEENUM_PostPrint,
     XFA_ATTRIBUTEENUM_PostSave,   XFA_ATTRIBUTEENUM_PostSign,
     XFA_ATTRIBUTEENUM_PostSubmit, XFA_ATTRIBUTEENUM_PreExecute,
     XFA_ATTRIBUTEENUM_PreOpen,    XFA_ATTRIBUTEENUM_PrePrint,
     XFA_ATTRIBUTEENUM_PreSave,    XFA_ATTRIBUTEENUM_PreSign,
     XFA_ATTRIBUTEENUM_PreSubmit,  XFA_ATTRIBUTEENUM_Ready,
     XFA_ATTRIBUTEENUM_Unknown,
 };
 
 CXFA_FFDocView::CXFA_FFDocView(CXFA_FFDoc* pDoc)
-    : m_bLayoutEvent(FALSE),
+    : m_bLayoutEvent(false),
       m_pListFocusWidget(nullptr),
-      m_bInLayoutStatus(FALSE),
+      m_bInLayoutStatus(false),
       m_pDoc(pDoc),
       m_pXFADocLayout(nullptr),
       m_pFocusAcc(nullptr),
       m_pFocusWidget(nullptr),
       m_pOldFocusWidget(nullptr),
       m_iStatus(XFA_DOCVIEW_LAYOUTSTATUS_None),
       m_iLock(0) {}
 
 CXFA_FFDocView::~CXFA_FFDocView() {
   DestroyDocView();
 }
 
 void CXFA_FFDocView::InitLayout(CXFA_Node* pNode) {
   RunBindItems();
-  ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Initialize, FALSE, TRUE,
+  ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Initialize, false, true,
                                nullptr);
-  ExecEventActivityByDeepFirst(pNode, XFA_EVENT_IndexChange, FALSE, TRUE,
+  ExecEventActivityByDeepFirst(pNode, XFA_EVENT_IndexChange, false, true,
                                nullptr);
 }
 int32_t CXFA_FFDocView::StartLayout(int32_t iStartPage) {
   m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_Start;
   m_pDoc->GetXFADoc()->DoProtoMerge();
   m_pDoc->GetXFADoc()->DoDataMerge();
   m_pXFADocLayout = GetXFALayout();
   int32_t iStatus = m_pXFADocLayout->StartLayout();
   if (iStatus < 0) {
     return iStatus;
   }
   CXFA_Node* pRootItem =
       ToNode(m_pDoc->GetXFADoc()->GetXFAObject(XFA_HASHCODE_Form));
   if (!pRootItem) {
     return iStatus;
   }
   InitLayout(pRootItem);
   InitCalculate(pRootItem);
   InitValidate(pRootItem);
-  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, TRUE, TRUE, nullptr);
+  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, true, true, nullptr);
   m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_Start;
   return iStatus;
 }
 int32_t CXFA_FFDocView::DoLayout(IFX_Pause* pPause) {
   int32_t iStatus = 100;
   iStatus = m_pXFADocLayout->DoLayout(pPause);
   if (iStatus != 100) {
     return iStatus;
   }
   m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_Doing;
@@ skipping 12 matching lines @@
   CXFA_Node* pPageSetNode =
       pSubformNode->GetFirstChildByClass(XFA_Element::PageSet);
   if (!pPageSetNode) {
     return;
   }
   RunCalculateWidgets();
   RunValidate();
   InitLayout(pPageSetNode);
   InitCalculate(pPageSetNode);
   InitValidate(pPageSetNode);
-  ExecEventActivityByDeepFirst(pPageSetNode, XFA_EVENT_Ready, TRUE, TRUE,
+  ExecEventActivityByDeepFirst(pPageSetNode, XFA_EVENT_Ready, true, true,
                                nullptr);
-  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, FALSE, TRUE,
+  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, false, true,
                                nullptr);
-  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_DocReady, FALSE, TRUE,
+  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_DocReady, false, true,
                                nullptr);
   RunCalculateWidgets();
   RunValidate();
   if (RunLayout()) {
-    ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, FALSE, TRUE,
+    ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, false, true,
                                  nullptr);
   }
   m_CalculateAccs.RemoveAll();
   if (m_pFocusAcc && !m_pFocusWidget) {
     SetFocusWidgetAcc(m_pFocusAcc);
   }
   m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_End;
 }
 int32_t CXFA_FFDocView::GetLayoutStatus() {
   return m_iStatus;
@@ skipping 27 matching lines @@
 void CXFA_FFDocView::UpdateDocView() {
   if (IsUpdateLocked()) {
     return;
   }
   LockUpdate();
   int32_t iNewAdds = m_NewAddedNodes.GetSize();
   for (int32_t i = 0; i < iNewAdds; i++) {
     CXFA_Node* pNode = m_NewAddedNodes[i];
     InitCalculate(pNode);
     InitValidate(pNode);
-    ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Ready, TRUE, TRUE, nullptr);
+    ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Ready, true, true, nullptr);
   }
   m_NewAddedNodes.RemoveAll();
   RunSubformIndexChange();
   RunCalculateWidgets();
   RunValidate();
   ShowNullTestMsg();
   if (RunLayout() && m_bLayoutEvent) {
     RunEventLayoutReady();
   }
-  m_bLayoutEvent = FALSE;
+  m_bLayoutEvent = false;
   m_CalculateAccs.RemoveAll();
   RunInvalidate();
   UnlockUpdate();
 }
 int32_t CXFA_FFDocView::CountPageViews() {
   if (!m_pXFADocLayout) {
     return 0;
   }
   return m_pXFADocLayout->CountPages();
 }
 CXFA_FFPageView* CXFA_FFDocView::GetPageView(int32_t nIndex) {
   if (!m_pXFADocLayout) {
     return nullptr;
   }
   return static_cast<CXFA_FFPageView*>(m_pXFADocLayout->GetPage(nIndex));
 }
 
 CXFA_LayoutProcessor* CXFA_FFDocView::GetXFALayout() const {
   return m_pDoc->GetXFADoc()->GetDocLayout();
 }
-FX_BOOL CXFA_FFDocView::ResetSingleWidgetAccData(CXFA_WidgetAcc* pWidgetAcc) {
+bool CXFA_FFDocView::ResetSingleWidgetAccData(CXFA_WidgetAcc* pWidgetAcc) {
   CXFA_Node* pNode = pWidgetAcc->GetNode();
   XFA_Element eType = pNode->GetElementType();
   if (eType != XFA_Element::Field && eType != XFA_Element::ExclGroup) {
-    return FALSE;
+    return false;
   }
   pWidgetAcc->ResetData();
   pWidgetAcc->UpdateUIDisplay();
   if (CXFA_Validate validate = pWidgetAcc->GetValidate()) {
     AddValidateWidget(pWidgetAcc);
     validate.GetNode()->SetFlag(XFA_NodeFlag_NeedsInitApp, false);
   }
-  return TRUE;
+  return true;
 }
 void CXFA_FFDocView::ResetWidgetData(CXFA_WidgetAcc* pWidgetAcc) {
-  m_bLayoutEvent = TRUE;
-  FX_BOOL bChanged = FALSE;
+  m_bLayoutEvent = true;
+  bool bChanged = false;
   CXFA_Node* pFormNode = nullptr;
   if (pWidgetAcc) {
     bChanged = ResetSingleWidgetAccData(pWidgetAcc);
     pFormNode = pWidgetAcc->GetNode();
   } else {
     pFormNode = GetRootSubform();
   }
   if (!pFormNode) {
     return;
   }
@@ skipping 30 matching lines @@
         CXFA_Node* pPresentNode =
             pConfigItem->GetChild(0, XFA_Element::Present);
         pValidateNode = pPresentNode
                             ? pPresentNode->GetChild(0, XFA_Element::Validate)
                             : nullptr;
       }
       if (pValidateNode) {
         wsValidateStr = pValidateNode->GetContent();
       }
     }
-    FX_BOOL bValidate = FALSE;
+    bool bValidate = false;
     switch (pParam->m_iValidateActivities) {
       case XFA_VALIDATE_preSubmit:
         bValidate = wsValidateStr.Find(L"preSubmit") != -1;
         break;
       case XFA_VALIDATE_prePrint:
         bValidate = wsValidateStr.Find(L"prePrint") != -1;
         break;
       case XFA_VALIDATE_preExecute:
         bValidate = wsValidateStr.Find(L"preExecute") != -1;
         break;
       case XFA_VALIDATE_preSave:
         bValidate = wsValidateStr.Find(L"preSave") != -1;
         break;
     }
     if (!bValidate) {
       return XFA_EVENTERROR_Success;
     }
   }
   CXFA_Node* pNode = pWidgetAcc ? pWidgetAcc->GetNode() : nullptr;
   if (!pNode) {
     CXFA_Node* pRootItem =
         ToNode(m_pDoc->GetXFADoc()->GetXFAObject(XFA_HASHCODE_Form));
     if (!pRootItem) {
       return XFA_EVENTERROR_Error;
     }
     pNode = pRootItem->GetChild(0, XFA_Element::Subform);
   }
   ExecEventActivityByDeepFirst(pNode, pParam->m_eType, pParam->m_bIsFormReady,
-                               TRUE, nullptr);
+                               true, nullptr);
   return XFA_EVENTERROR_Success;
 }
 CXFA_FFWidgetHandler* CXFA_FFDocView::GetWidgetHandler() {
   if (!m_pWidgetHandler) {
     m_pWidgetHandler.reset(new CXFA_FFWidgetHandler(this));
   }
   return m_pWidgetHandler.get();
 }
 
 CXFA_WidgetAccIterator* CXFA_FFDocView::CreateWidgetAccIterator(
     XFA_WIDGETORDER eOrder) {
   CXFA_Node* pFormRoot = GetRootSubform();
   return pFormRoot ? new CXFA_WidgetAccIterator(this, pFormRoot) : nullptr;
 }
 CXFA_FFWidget* CXFA_FFDocView::GetFocusWidget() {
   return m_pFocusWidget;
 }
 void CXFA_FFDocView::KillFocus() {
   if (m_pFocusWidget &&
       (m_pFocusWidget->GetStatus() & XFA_WidgetStatus_Focused)) {
     (m_pFocusWidget)->OnKillFocus(nullptr);
   }
   m_pFocusAcc = nullptr;
   m_pFocusWidget = nullptr;
   m_pOldFocusWidget = nullptr;
 }
-FX_BOOL CXFA_FFDocView::SetFocus(CXFA_FFWidget* hWidget) {
+bool CXFA_FFDocView::SetFocus(CXFA_FFWidget* hWidget) {
   CXFA_FFWidget* pNewFocus = hWidget;
   if (m_pOldFocusWidget == pNewFocus) {
-    return FALSE;
+    return false;
   }
   CXFA_FFWidget* pOldFocus = m_pOldFocusWidget;
   m_pOldFocusWidget = pNewFocus;
   if (pOldFocus) {
     if (m_pFocusWidget != m_pOldFocusWidget &&
         (pOldFocus->GetStatus() & XFA_WidgetStatus_Focused)) {
       m_pFocusWidget = pOldFocus;
       pOldFocus->OnKillFocus(pNewFocus);
     } else if ((pOldFocus->GetStatus() & XFA_WidgetStatus_Visible)) {
       if (!pOldFocus->IsLoaded()) {
         pOldFocus->LoadWidget();
       }
       pOldFocus->OnSetFocus(m_pFocusWidget);
       m_pFocusWidget = pOldFocus;
       pOldFocus->OnKillFocus(pNewFocus);
     }
   }
   if (m_pFocusWidget == m_pOldFocusWidget) {
-    return FALSE;
+    return false;
   }
   pNewFocus = m_pOldFocusWidget;
   if (m_pListFocusWidget && pNewFocus == m_pListFocusWidget) {
     m_pFocusAcc = nullptr;
     m_pFocusWidget = nullptr;
     m_pListFocusWidget = nullptr;
     m_pOldFocusWidget = nullptr;
-    return FALSE;
+    return false;
   }
   if (pNewFocus && (pNewFocus->GetStatus() & XFA_WidgetStatus_Visible)) {
     if (!pNewFocus->IsLoaded()) {
       pNewFocus->LoadWidget();
     }
     pNewFocus->OnSetFocus(m_pFocusWidget);
   }
   m_pFocusAcc = pNewFocus ? pNewFocus->GetDataAcc() : nullptr;
   m_pFocusWidget = pNewFocus;
   m_pOldFocusWidget = m_pFocusWidget;
-  return TRUE;
+  return true;
 }
 CXFA_WidgetAcc* CXFA_FFDocView::GetFocusWidgetAcc() {
   return m_pFocusAcc;
 }
 void CXFA_FFDocView::SetFocusWidgetAcc(CXFA_WidgetAcc* pWidgetAcc) {
   CXFA_FFWidget* pNewFocus =
       pWidgetAcc ? pWidgetAcc->GetNextWidget(nullptr) : nullptr;
   if (SetFocus(pNewFocus)) {
     m_pFocusAcc = pWidgetAcc;
     if (m_iStatus == XFA_DOCVIEW_LAYOUTSTATUS_End) {
@@ skipping 40 matching lines @@
     }
     default:
       break;
   }
   int32_t iRet =
       pWidgetAcc->ProcessEvent(gs_EventActivity[pParam->m_eType], pParam);
   return iRet;
 }
 int32_t CXFA_FFDocView::ExecEventActivityByDeepFirst(CXFA_Node* pFormNode,
                                                      XFA_EVENTTYPE eEventType,
-                                                     FX_BOOL bIsFormReady,
-                                                     FX_BOOL bRecursive,
+                                                     bool bIsFormReady,
+                                                     bool bRecursive,
                                                      CXFA_Node* pExclude) {
   int32_t iRet = XFA_EVENTERROR_NotExist;
   if (pFormNode == pExclude) {
     return iRet;
   }
   XFA_Element elementType = pFormNode->GetElementType();
   if (elementType == XFA_Element::Field) {
     if (eEventType == XFA_EVENT_IndexChange) {
       return iRet;
     }
@@ skipping 76 matching lines @@
   CXFA_FFPageView* pFFPageView = static_cast<CXFA_FFPageView*>(pSender);
   m_pDoc->GetDocEnvironment()->PageViewEvent(pFFPageView, dwEvent);
 }
 
 void CXFA_FFDocView::LockUpdate() {
   m_iLock++;
 }
 void CXFA_FFDocView::UnlockUpdate() {
   m_iLock--;
 }
-FX_BOOL CXFA_FFDocView::IsUpdateLocked() {
+bool CXFA_FFDocView::IsUpdateLocked() {
   return m_iLock > 0;
 }
 void CXFA_FFDocView::ClearInvalidateList() {
   m_mapPageInvalidate.clear();
 }
 void CXFA_FFDocView::AddInvalidateRect(CXFA_FFWidget* pWidget,
                                        const CFX_RectF& rtInvalidate) {
   AddInvalidateRect(pWidget->GetPageView(), rtInvalidate);
 }
 
 void CXFA_FFDocView::AddInvalidateRect(CXFA_FFPageView* pPageView,
                                        const CFX_RectF& rtInvalidate) {
   if (m_mapPageInvalidate[pPageView]) {
     m_mapPageInvalidate[pPageView]->Union(rtInvalidate);
     return;
   }
   CFX_RectF* pRect = new CFX_RectF;
   pRect->Set(rtInvalidate.left, rtInvalidate.top, rtInvalidate.width,
              rtInvalidate.height);
   m_mapPageInvalidate[pPageView].reset(pRect);
 }
 
 void CXFA_FFDocView::RunInvalidate() {
   for (const auto& pair : m_mapPageInvalidate)
     m_pDoc->GetDocEnvironment()->InvalidateRect(pair.first, *pair.second, 0);
   m_mapPageInvalidate.clear();
 }
 
-FX_BOOL CXFA_FFDocView::RunLayout() {
+bool CXFA_FFDocView::RunLayout() {
   LockUpdate();
-  m_bInLayoutStatus = TRUE;
+  m_bInLayoutStatus = true;
   if (!m_pXFADocLayout->IncrementLayout() &&
       m_pXFADocLayout->StartLayout() < 100) {
     m_pXFADocLayout->DoLayout();
     UnlockUpdate();
-    m_bInLayoutStatus = FALSE;
+    m_bInLayoutStatus = false;
     m_pDoc->GetDocEnvironment()->PageViewEvent(nullptr,
                                                XFA_PAGEVIEWEVENT_StopLayout);
-    return TRUE;
+    return true;
   }
-  m_bInLayoutStatus = FALSE;
+  m_bInLayoutStatus = false;
   m_pDoc->GetDocEnvironment()->PageViewEvent(nullptr,
                                              XFA_PAGEVIEWEVENT_StopLayout);
   UnlockUpdate();
-  return FALSE;
+  return false;
 }
 void CXFA_FFDocView::RunSubformIndexChange() {
   int32_t iSubforms = m_IndexChangedSubforms.GetSize();
   for (int32_t i = 0; i < iSubforms; i++) {
     CXFA_Node* pSubformNode = m_IndexChangedSubforms[i];
     CXFA_WidgetAcc* pWidgetAcc =
         static_cast<CXFA_WidgetAcc*>(pSubformNode->GetWidgetData());
     if (!pWidgetAcc) {
       continue;
     }
@@ skipping 11 matching lines @@
 void CXFA_FFDocView::AddIndexChangedSubform(CXFA_Node* pNode) {
   ASSERT(pNode->GetElementType() == XFA_Element::Subform);
   m_IndexChangedSubforms.Add(pNode);
 }
 void CXFA_FFDocView::RunDocClose() {
   CXFA_Node* pRootItem =
       ToNode(m_pDoc->GetXFADoc()->GetXFAObject(XFA_HASHCODE_Form));
   if (!pRootItem) {
     return;
   }
-  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_DocClose, FALSE, TRUE,
+  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_DocClose, false, true,
                                nullptr);
 }
 void CXFA_FFDocView::DestroyDocView() {
   ClearInvalidateList();
   m_iStatus = XFA_DOCVIEW_LAYOUTSTATUS_None;
   m_iLock = 0;
   m_ValidateAccs.RemoveAll();
   m_BindItems.RemoveAll();
   m_CalculateAccs.RemoveAll();
 }
-FX_BOOL CXFA_FFDocView::IsStaticNotify() {
+bool CXFA_FFDocView::IsStaticNotify() {
   return m_pDoc->GetDocType() == XFA_DOCTYPE_Static;
 }
 void CXFA_FFDocView::AddCalculateWidgetAcc(CXFA_WidgetAcc* pWidgetAcc) {
   int32_t iAccs = m_CalculateAccs.GetSize();
   CXFA_WidgetAcc* pCurrentAcc =
       iAccs > 0 ? m_CalculateAccs[iAccs - 1] : nullptr;
   if (pCurrentAcc != pWidgetAcc) {
     m_CalculateAccs.Add(pWidgetAcc);
   }
 }
@@ skipping 46 matching lines @@
     CXFA_WidgetAcc* pCurAcc = m_CalculateAccs[i];
     pCurAcc->GetNode()->SetUserData(XFA_CalcRefCount, (void*)(uintptr_t)0);
   }
   m_CalculateAccs.RemoveAll();
   return XFA_EVENTERROR_Success;
 }
 void CXFA_FFDocView::AddValidateWidget(CXFA_WidgetAcc* pWidget) {
   if (m_ValidateAccs.Find(pWidget) < 0)
     m_ValidateAccs.Add(pWidget);
 }
-FX_BOOL CXFA_FFDocView::InitCalculate(CXFA_Node* pNode) {
-  ExecEventActivityByDeepFirst(pNode, XFA_EVENT_InitCalculate, FALSE, TRUE,
+bool CXFA_FFDocView::InitCalculate(CXFA_Node* pNode) {
+  ExecEventActivityByDeepFirst(pNode, XFA_EVENT_InitCalculate, false, true,
                                nullptr);
-  return TRUE;
+  return true;
 }
-FX_BOOL CXFA_FFDocView::InitValidate(CXFA_Node* pNode) {
+bool CXFA_FFDocView::InitValidate(CXFA_Node* pNode) {
   if (!m_pDoc->GetDocEnvironment()->IsValidationsEnabled(m_pDoc)) {
-    return FALSE;
+    return false;
   }
-  ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Validate, FALSE, TRUE, nullptr);
+  ExecEventActivityByDeepFirst(pNode, XFA_EVENT_Validate, false, true, nullptr);
   m_ValidateAccs.RemoveAll();
-  return TRUE;
+  return true;
 }
-FX_BOOL CXFA_FFDocView::RunValidate() {
+bool CXFA_FFDocView::RunValidate() {
   if (!m_pDoc->GetDocEnvironment()->IsValidationsEnabled(m_pDoc)) {
-    return FALSE;
+    return false;
   }
   int32_t iCounts = m_ValidateAccs.GetSize();
   for (int32_t i = 0; i < iCounts; i++) {
     CXFA_WidgetAcc* pAcc = m_ValidateAccs[i];
     if (pAcc->GetNode()->HasRemovedChildren())
       continue;
 
     pAcc->ProcessValidate();
   }
   m_ValidateAccs.RemoveAll();
-  return TRUE;
+  return true;
 }
-FX_BOOL CXFA_FFDocView::RunEventLayoutReady() {
+bool CXFA_FFDocView::RunEventLayoutReady() {
   CXFA_Node* pRootItem =
       ToNode(m_pDoc->GetXFADoc()->GetXFAObject(XFA_HASHCODE_Form));
   if (!pRootItem) {
-    return FALSE;
+    return false;
   }
-  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, FALSE, TRUE,
+  ExecEventActivityByDeepFirst(pRootItem, XFA_EVENT_Ready, false, true,
                                nullptr);
   RunLayout();
-  return TRUE;
+  return true;
 }
 void CXFA_FFDocView::RunBindItems() {
   for (int32_t i = 0; i < m_BindItems.GetSize(); i++) {
     if (m_BindItems[i]->HasRemovedChildren())
       continue;
 
     CXFA_Node* pWidgetNode = m_BindItems[i]->GetNodeItem(XFA_NODEITEM_Parent);
     CXFA_WidgetAcc* pAcc =
         static_cast<CXFA_WidgetAcc*>(pWidgetNode->GetWidgetData());
     if (!pAcc)
@@ skipping 101 matching lines @@
 }
 
 CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToPrevious() {
   return nullptr;
 }
 
 CXFA_WidgetAcc* CXFA_WidgetAccIterator::GetCurrentWidgetAcc() {
   return nullptr;
 }
 
-FX_BOOL CXFA_WidgetAccIterator::SetCurrentWidgetAcc(CXFA_WidgetAcc* hWidget) {
-  return FALSE;
+bool CXFA_WidgetAccIterator::SetCurrentWidgetAcc(CXFA_WidgetAcc* hWidget) {
+  return false;
 }
 
 void CXFA_WidgetAccIterator::SkipTree() {
   m_ContentIterator.SkipChildrenAndMoveToNext();
   m_pCurWidgetAcc = nullptr;
 }