diff --git a/fpdfsdk/cpdfsdk_pageview.cpp b/fpdfsdk/cpdfsdk_pageview.cpp
index 5aeb2df..32d8a90 100644
--- a/fpdfsdk/cpdfsdk_pageview.cpp
+++ b/fpdfsdk/cpdfsdk_pageview.cpp
@@ -491,13 +491,9 @@
   auto* pContext = m_pFormFillEnv->GetDocExtension();
   if (pContext->ContainsExtensionFullForm()) {
     CXFA_FFPageView* pageView = protector->GetXFAPageView();
-    std::unique_ptr<IXFA_WidgetIterator> pWidgetHandler(
-        pageView->CreateWidgetIterator(
-            XFA_TRAVERSEWAY_Form,
-            XFA_WidgetStatus_Visible | XFA_WidgetStatus_Viewable));
-    if (!pWidgetHandler) {
-      return;
-    }
+    std::unique_ptr<IXFA_WidgetIterator> pWidgetHandler =
+        pageView->CreateFormWidgetIterator(XFA_WidgetStatus_Visible |
+                                           XFA_WidgetStatus_Viewable);
 
     while (CXFA_FFWidget* pXFAAnnot = pWidgetHandler->MoveToNext()) {
       std::unique_ptr<CPDFSDK_Annot> pNewAnnot =
diff --git a/fpdfsdk/fpdfxfa/cpdfxfa_page.cpp b/fpdfsdk/fpdfxfa/cpdfxfa_page.cpp
index 79b3e87..9797429 100644
--- a/fpdfsdk/fpdfxfa/cpdfxfa_page.cpp
+++ b/fpdfsdk/fpdfxfa/cpdfxfa_page.cpp
@@ -182,14 +182,13 @@
 
   ObservedPtr<CPDFSDK_Annot> pObservedAnnot(pSDKAnnot);
   CPDFSDK_PageView* pPageView = pSDKAnnot->GetPageView();
-  std::unique_ptr<IXFA_WidgetIterator> pWidgetIterator(
-      GetXFAPageView()->CreateWidgetIterator(XFA_TRAVERSEWAY_Tranvalse,
-                                             XFA_WidgetStatus_Visible |
-                                                 XFA_WidgetStatus_Viewable |
-                                                 XFA_WidgetStatus_Focused));
+  std::unique_ptr<IXFA_WidgetIterator> pWidgetIterator =
+      GetXFAPageView()->CreateTraverseWidgetIterator(XFA_WidgetStatus_Visible |
+                                                     XFA_WidgetStatus_Viewable |
+                                                     XFA_WidgetStatus_Focused);
 
   // Check |pSDKAnnot| again because JS may have destroyed it
-  if (!pObservedAnnot || !pWidgetIterator)
+  if (!pObservedAnnot)
     return nullptr;
 
   if (pWidgetIterator->GetCurrentWidget() != pXFAWidget->GetXFAFFWidget())
@@ -216,11 +215,8 @@
   if (!pWidgetHandler)
     return -1;
 
-  std::unique_ptr<IXFA_WidgetIterator> pWidgetIterator(
-      pPageView->CreateWidgetIterator(XFA_TRAVERSEWAY_Form,
-                                      XFA_WidgetStatus_Viewable));
-  if (!pWidgetIterator)
-    return -1;
+  std::unique_ptr<IXFA_WidgetIterator> pWidgetIterator =
+      pPageView->CreateFormWidgetIterator(XFA_WidgetStatus_Viewable);
 
   CXFA_FFWidget* pXFAAnnot;
   while ((pXFAAnnot = pWidgetIterator->MoveToNext()) != nullptr) {
diff --git a/xfa/fxfa/cxfa_ffpageview.cpp b/xfa/fxfa/cxfa_ffpageview.cpp
index d517969..1915152 100644
--- a/xfa/fxfa/cxfa_ffpageview.cpp
+++ b/xfa/fxfa/cxfa_ffpageview.cpp
@@ -129,18 +129,15 @@
                        iRotate, 0);
 }
 
-std::unique_ptr<IXFA_WidgetIterator> CXFA_FFPageView::CreateWidgetIterator(
-    uint32_t dwTraverseWay,
+std::unique_ptr<IXFA_WidgetIterator> CXFA_FFPageView::CreateFormWidgetIterator(
     uint32_t dwWidgetFilter) {
-  switch (dwTraverseWay) {
-    case XFA_TRAVERSEWAY_Tranvalse:
-      return pdfium::MakeUnique<CXFA_FFTabOrderPageWidgetIterator>(
-          this, dwWidgetFilter);
-    case XFA_TRAVERSEWAY_Form:
-      return pdfium::MakeUnique<CXFA_FFPageWidgetIterator>(this,
-                                                           dwWidgetFilter);
-  }
-  return nullptr;
+  return pdfium::MakeUnique<CXFA_FFPageWidgetIterator>(this, dwWidgetFilter);
+}
+
+std::unique_ptr<IXFA_WidgetIterator>
+CXFA_FFPageView::CreateTraverseWidgetIterator(uint32_t dwWidgetFilter) {
+  return pdfium::MakeUnique<CXFA_FFTabOrderPageWidgetIterator>(this,
+                                                               dwWidgetFilter);
 }
 
 CXFA_FFPageWidgetIterator::CXFA_FFPageWidgetIterator(CXFA_FFPageView* pPageView,
diff --git a/xfa/fxfa/cxfa_ffpageview.h b/xfa/fxfa/cxfa_ffpageview.h
old mode 100755
new mode 100644
index d49c69c..65c0b95
--- a/xfa/fxfa/cxfa_ffpageview.h
+++ b/xfa/fxfa/cxfa_ffpageview.h
@@ -29,8 +29,11 @@
   CXFA_FFDocView* GetDocView() const;
   CFX_RectF GetPageViewRect() const;
   CFX_Matrix GetDisplayMatrix(const FX_RECT& rtDisp, int32_t iRotate) const;
-  std::unique_ptr<IXFA_WidgetIterator> CreateWidgetIterator(
-      uint32_t dwTraverseWay,
+
+  // These always return a non-null iterator.
+  std::unique_ptr<IXFA_WidgetIterator> CreateFormWidgetIterator(
+      uint32_t dwWidgetFilter);
+  std::unique_ptr<IXFA_WidgetIterator> CreateTraverseWidgetIterator(
       uint32_t dwWidgetFilter);
 
  private:
diff --git a/xfa/fxfa/cxfa_rendercontext.cpp b/xfa/fxfa/cxfa_rendercontext.cpp
index 572cda5..106fcbe 100644
--- a/xfa/fxfa/cxfa_rendercontext.cpp
+++ b/xfa/fxfa/cxfa_rendercontext.cpp
@@ -12,8 +12,7 @@
 CXFA_RenderContext::CXFA_RenderContext(CXFA_FFPageView* pPageView,
                                        const CFX_RectF& clipRect,
                                        const CFX_Matrix& matrix)
-    : m_pWidgetIterator(pPageView->CreateWidgetIterator(
-          XFA_TRAVERSEWAY_Form,
+    : m_pWidgetIterator(pPageView->CreateFormWidgetIterator(
           XFA_WidgetStatus_Visible | XFA_WidgetStatus_Viewable)),
       m_pWidget(m_pWidgetIterator->MoveToNext()),
       m_matrix(matrix),
diff --git a/xfa/fxfa/fxfa.h b/xfa/fxfa/fxfa.h
index 9193d1b..5c01da5 100644
--- a/xfa/fxfa/fxfa.h
+++ b/xfa/fxfa/fxfa.h
@@ -68,9 +68,6 @@
 #define XFA_PAGEVIEWEVENT_PostRemoved 3
 #define XFA_PAGEVIEWEVENT_StopLayout 4
 
-#define XFA_TRAVERSEWAY_Tranvalse 0x0001
-#define XFA_TRAVERSEWAY_Form 0x0002
-
 enum class XFA_EventError {
   kError = -1,
   kNotExist = 0,
