Make many CXFA_NodeHelper methods static.

Also move private methods into an anonymous namespace, split
GetNameExpression() into a public method and an anonymous one, and fix
some nits.

Change-Id: I1edea74461fc53cdea77dee6812b6c3007145c1e
Reviewed-on: https://pdfium-review.googlesource.com/c/pdfium/+/52181
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
diff --git a/fxjs/xfa/cfxjse_engine.cpp b/fxjs/xfa/cfxjse_engine.cpp
index 5a9fd5a..26495e9 100644
--- a/fxjs/xfa/cfxjse_engine.cpp
+++ b/fxjs/xfa/cfxjse_engine.cpp
@@ -758,20 +758,19 @@
 }
 
 int32_t CFXJSE_Engine::GetIndexByName(CXFA_Node* refNode) {
-  CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
-  return lpNodeHelper->GetIndex(refNode, XFA_LOGIC_Transparent,
-                                lpNodeHelper->NodeIsProperty(refNode), false);
+  return CXFA_NodeHelper::GetIndex(refNode, XFA_LOGIC_Transparent,
+                                   CXFA_NodeHelper::NodeIsProperty(refNode),
+                                   false);
 }
 
 int32_t CFXJSE_Engine::GetIndexByClassName(CXFA_Node* refNode) {
-  CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
-  return lpNodeHelper->GetIndex(refNode, XFA_LOGIC_Transparent,
-                                lpNodeHelper->NodeIsProperty(refNode), true);
+  return CXFA_NodeHelper::GetIndex(refNode, XFA_LOGIC_Transparent,
+                                   CXFA_NodeHelper::NodeIsProperty(refNode),
+                                   true);
 }
 
 WideString CFXJSE_Engine::GetSomExpression(CXFA_Node* refNode) {
-  CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
-  return lpNodeHelper->GetNameExpression(refNode, true);
+  return CXFA_NodeHelper::GetNameExpression(refNode);
 }
 
 void CFXJSE_Engine::SetNodesOfRunScript(std::vector<CXFA_Node*>* pArray) {
diff --git a/fxjs/xfa/cfxjse_resolveprocessor.cpp b/fxjs/xfa/cfxjse_resolveprocessor.cpp
index 5a8e69a..1605be6 100644
--- a/fxjs/xfa/cfxjse_resolveprocessor.cpp
+++ b/fxjs/xfa/cfxjse_resolveprocessor.cpp
@@ -96,11 +96,11 @@
   bool bClassName = false;
   if (wsName.GetLength() && wsName[0] == '#') {
     bClassName = true;
-    findNode = m_pNodeHelper->GetOneChildOfClass(
+    findNode = CXFA_NodeHelper::GetOneChildOfClass(
         ToNode(rnd.m_CurObject.Get()), wsName.Right(wsName.GetLength() - 1));
   } else {
-    findNode =
-        m_pNodeHelper->GetOneChildNamed(ToNode(rnd.m_CurObject.Get()), wsName);
+    findNode = CXFA_NodeHelper::GetOneChildNamed(ToNode(rnd.m_CurObject.Get()),
+                                                 wsName);
   }
   if (!findNode)
     return false;
@@ -113,8 +113,8 @@
   std::vector<CXFA_Node*> tempNodes;
   for (const auto& pObject : rnd.m_Objects)
     tempNodes.push_back(pObject->AsNode());
-  m_pNodeHelper->CountSiblings(findNode, XFA_LOGIC_Transparent, &tempNodes,
-                               bClassName);
+  CXFA_NodeHelper::CountSiblings(findNode, XFA_LOGIC_Transparent, &tempNodes,
+                                 bClassName);
   rnd.m_Objects =
       std::vector<UnownedPtr<CXFA_Object>>(tempNodes.begin(), tempNodes.end());
   FilterCondition(rnd, wsCondition);
@@ -284,7 +284,7 @@
         rnd.m_Objects.emplace_back(child);
       }
 
-      if (m_pNodeHelper->NodeIsTransparent(child) &&
+      if (CXFA_NodeHelper::NodeIsTransparent(child) &&
           child->GetElementType() != XFA_Element::PageSet) {
         if (!bSetFlag) {
           SetStylesForChild(dwStyles, rndFind);
@@ -303,10 +303,10 @@
     if (rnd.m_Objects.size() > nNum) {
       if (!(dwStyles & XFA_RESOLVENODE_ALL)) {
         std::vector<CXFA_Node*> upArrayNodes;
-        if (m_pNodeHelper->NodeIsTransparent(ToNode(curNode))) {
-          m_pNodeHelper->CountSiblings(ToNode(rnd.m_Objects.front().Get()),
-                                       XFA_LOGIC_Transparent, &upArrayNodes,
-                                       !!(dwStyles & XFA_RESOLVENODE_TagName));
+        if (CXFA_NodeHelper::NodeIsTransparent(ToNode(curNode))) {
+          CXFA_NodeHelper::CountSiblings(
+              ToNode(rnd.m_Objects.front().Get()), XFA_LOGIC_Transparent,
+              &upArrayNodes, !!(dwStyles & XFA_RESOLVENODE_TagName));
         }
         if (upArrayNodes.size() > rnd.m_Objects.size()) {
           CXFA_Object* pSaveObject = rnd.m_Objects.front().Get();
@@ -366,7 +366,7 @@
   }
 
   CXFA_Node* parentNode =
-      m_pNodeHelper->GetParent(curNode->AsNode(), XFA_LOGIC_NoTransparent);
+      CXFA_NodeHelper::GetParent(curNode->AsNode(), XFA_LOGIC_NoTransparent);
   uint32_t uCurClassHash = curNode->GetClassHashCode();
   if (!parentNode) {
     if (uCurClassHash == uNameHash) {
@@ -420,7 +420,7 @@
              child->GetElementType() == XFA_Element::PageSet)) {
           bInnerSearch = true;
         }
-      } else if (m_pNodeHelper->NodeIsTransparent(child)) {
+      } else if (CXFA_NodeHelper::NodeIsTransparent(child)) {
         bInnerSearch = true;
       }
       if (bInnerSearch) {
@@ -438,11 +438,11 @@
       child = child->GetNextSibling();
     }
     if (rnd.m_Objects.size() > nNum) {
-      if (m_pNodeHelper->NodeIsTransparent(parentNode)) {
+      if (CXFA_NodeHelper::NodeIsTransparent(parentNode)) {
         std::vector<CXFA_Node*> upArrayNodes;
-        m_pNodeHelper->CountSiblings(ToNode(rnd.m_Objects.front().Get()),
-                                     XFA_LOGIC_Transparent, &upArrayNodes,
-                                     !!(dwStyles & XFA_RESOLVENODE_TagName));
+        CXFA_NodeHelper::CountSiblings(ToNode(rnd.m_Objects.front().Get()),
+                                       XFA_LOGIC_Transparent, &upArrayNodes,
+                                       !!(dwStyles & XFA_RESOLVENODE_TagName));
         if (upArrayNodes.size() > rnd.m_Objects.size()) {
           CXFA_Object* pSaveObject = rnd.m_Objects.front().Get();
           rnd.m_Objects = std::vector<UnownedPtr<CXFA_Object>>(
@@ -651,15 +651,12 @@
   const std::vector<CXFA_Node*>* pArray = rnd.m_pSC->GetUpObjectArray();
   if (!pArray->empty()) {
     CXFA_Node* curNode = pArray->back();
-    bool bIsProperty = m_pNodeHelper->NodeIsProperty(curNode);
-    if (curNode->IsUnnamed() ||
-        (bIsProperty && curNode->GetElementType() != XFA_Element::PageSet)) {
-      iCurrIndex = m_pNodeHelper->GetIndex(curNode, XFA_LOGIC_Transparent,
-                                           bIsProperty, true);
-    } else {
-      iCurrIndex = m_pNodeHelper->GetIndex(curNode, XFA_LOGIC_Transparent,
-                                           bIsProperty, false);
-    }
+    bool bIsProperty = CXFA_NodeHelper::NodeIsProperty(curNode);
+    bool bIsClassIndex =
+        curNode->IsUnnamed() ||
+        (bIsProperty && curNode->GetElementType() != XFA_Element::PageSet);
+    iCurrIndex = CXFA_NodeHelper::GetIndex(curNode, XFA_LOGIC_Transparent,
+                                           bIsProperty, bIsClassIndex);
   }
 
   int32_t iFoundCount = pdfium::CollectionSize<int32_t>(rnd.m_Objects);
@@ -731,4 +728,4 @@
 CFXJSE_ResolveNodeData::CFXJSE_ResolveNodeData(CFXJSE_Engine* pSC)
     : m_pSC(pSC) {}
 
-CFXJSE_ResolveNodeData::~CFXJSE_ResolveNodeData() {}
+CFXJSE_ResolveNodeData::~CFXJSE_ResolveNodeData() = default;
diff --git a/xfa/fxfa/parser/cxfa_nodehelper.cpp b/xfa/fxfa/parser/cxfa_nodehelper.cpp
index 10d5e8b..cab5625 100644
--- a/xfa/fxfa/parser/cxfa_nodehelper.cpp
+++ b/xfa/fxfa/parser/cxfa_nodehelper.cpp
@@ -18,32 +18,16 @@
 #include "xfa/fxfa/parser/xfa_resolvenode_rs.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
 
-CXFA_NodeHelper::CXFA_NodeHelper() = default;
+namespace {
 
-CXFA_NodeHelper::~CXFA_NodeHelper() = default;
+CXFA_Node* FindFirstSiblingNamedInList(CXFA_Node* parent,
+                                       uint32_t dNameHash,
+                                       uint32_t dwFilter);
+CXFA_Node* FindFirstSiblingOfClassInList(CXFA_Node* parent,
+                                         XFA_Element element,
+                                         uint32_t dwFilter);
 
-CXFA_Node* CXFA_NodeHelper::GetOneChildNamed(CXFA_Node* parent,
-                                             WideStringView wsName) {
-  if (!parent)
-    return nullptr;
-
-  return FindFirstSiblingNamed(parent, FX_HashCode_GetW(wsName, false));
-}
-
-CXFA_Node* CXFA_NodeHelper::GetOneChildOfClass(CXFA_Node* parent,
-                                               WideStringView wsClass) {
-  if (!parent)
-    return nullptr;
-
-  XFA_Element element = XFA_GetElementByName(wsClass);
-  if (element == XFA_Element::Unknown)
-    return nullptr;
-
-  return FindFirstSiblingOfClass(parent, element);
-}
-
-CXFA_Node* CXFA_NodeHelper::FindFirstSiblingNamed(CXFA_Node* parent,
-                                                  uint32_t dNameHash) {
+CXFA_Node* FindFirstSiblingNamed(CXFA_Node* parent, uint32_t dNameHash) {
   CXFA_Node* result =
       FindFirstSiblingNamedInList(parent, dNameHash, XFA_NODEFILTER_Properties);
   if (result)
@@ -53,9 +37,9 @@
                                      XFA_NODEFILTER_Children);
 }
 
-CXFA_Node* CXFA_NodeHelper::FindFirstSiblingNamedInList(CXFA_Node* parent,
-                                                        uint32_t dNameHash,
-                                                        uint32_t dwFilter) {
+CXFA_Node* FindFirstSiblingNamedInList(CXFA_Node* parent,
+                                       uint32_t dNameHash,
+                                       uint32_t dwFilter) {
   for (CXFA_Node* child : parent->GetNodeList(dwFilter, XFA_Element::Unknown)) {
     if (child->GetNameHash() == dNameHash)
       return child;
@@ -67,8 +51,7 @@
   return nullptr;
 }
 
-CXFA_Node* CXFA_NodeHelper::FindFirstSiblingOfClass(CXFA_Node* parent,
-                                                    XFA_Element element) {
+CXFA_Node* FindFirstSiblingOfClass(CXFA_Node* parent, XFA_Element element) {
   CXFA_Node* result =
       FindFirstSiblingOfClassInList(parent, element, XFA_NODEFILTER_Properties);
   if (result)
@@ -78,9 +61,9 @@
                                        XFA_NODEFILTER_Children);
 }
 
-CXFA_Node* CXFA_NodeHelper::FindFirstSiblingOfClassInList(CXFA_Node* parent,
-                                                          XFA_Element element,
-                                                          uint32_t dwFilter) {
+CXFA_Node* FindFirstSiblingOfClassInList(CXFA_Node* parent,
+                                         XFA_Element element,
+                                         uint32_t dwFilter) {
   for (CXFA_Node* child : parent->GetNodeList(dwFilter, XFA_Element::Unknown)) {
     if (child->GetElementType() == element)
       return child;
@@ -92,35 +75,12 @@
   return nullptr;
 }
 
-int32_t CXFA_NodeHelper::CountSiblings(CXFA_Node* pNode,
-                                       XFA_LOGIC_TYPE eLogicType,
-                                       std::vector<CXFA_Node*>* pSiblings,
-                                       bool bIsClassName) {
-  if (!pNode)
-    return 0;
-  CXFA_Node* parent = GetParent(pNode, XFA_LOGIC_NoTransparent);
-  if (!parent)
-    return 0;
-  if (!parent->HasProperty(pNode->GetElementType()) &&
-      eLogicType == XFA_LOGIC_Transparent) {
-    parent = GetParent(pNode, XFA_LOGIC_Transparent);
-    if (!parent)
-      return 0;
-  }
-  if (bIsClassName) {
-    return TraverseSiblings(parent, pNode->GetClassHashCode(), pSiblings,
-                            eLogicType, bIsClassName, true);
-  }
-  return TraverseSiblings(parent, pNode->GetNameHash(), pSiblings, eLogicType,
-                          bIsClassName, true);
-}
-
-int32_t CXFA_NodeHelper::TraverseSiblings(CXFA_Node* parent,
-                                          uint32_t dNameHash,
-                                          std::vector<CXFA_Node*>* pSiblings,
-                                          XFA_LOGIC_TYPE eLogicType,
-                                          bool bIsClassName,
-                                          bool bIsFindProperty) {
+int32_t TraverseSiblings(CXFA_Node* parent,
+                         uint32_t dNameHash,
+                         std::vector<CXFA_Node*>* pSiblings,
+                         XFA_LOGIC_TYPE eLogicType,
+                         bool bIsClassName,
+                         bool bIsFindProperty) {
   if (!parent || !pSiblings)
     return 0;
 
@@ -171,7 +131,7 @@
     if (eLogicType == XFA_LOGIC_NoTransparent)
       continue;
 
-    if (NodeIsTransparent(child) &&
+    if (CXFA_NodeHelper::NodeIsTransparent(child) &&
         child->GetElementType() != XFA_Element::PageSet) {
       nCount += TraverseSiblings(child, dNameHash, pSiblings, eLogicType,
                                  bIsClassName, false);
@@ -180,21 +140,92 @@
   return nCount;
 }
 
+WideString GetNameExpressionSinglePath(CXFA_Node* refNode) {
+  WideString ws;
+  bool bIsProperty = CXFA_NodeHelper::NodeIsProperty(refNode);
+  if (refNode->IsUnnamed() ||
+      (bIsProperty && refNode->GetElementType() != XFA_Element::PageSet)) {
+    ws = WideString::FromASCII(refNode->GetClassName());
+    return WideString::Format(
+        L"#%ls[%d]", ws.c_str(),
+        CXFA_NodeHelper::GetIndex(refNode, XFA_LOGIC_Transparent, bIsProperty,
+                                  true));
+  }
+  ws = refNode->JSObject()->GetCData(XFA_Attribute::Name);
+  ws.Replace(L".", L"\\.");
+  return WideString::Format(
+      L"%ls[%d]", ws.c_str(),
+      CXFA_NodeHelper::GetIndex(refNode, XFA_LOGIC_Transparent, bIsProperty,
+                                false));
+}
+
+}  // namespace
+
+CXFA_NodeHelper::CXFA_NodeHelper() = default;
+
+CXFA_NodeHelper::~CXFA_NodeHelper() = default;
+
+// static
+CXFA_Node* CXFA_NodeHelper::GetOneChildNamed(CXFA_Node* parent,
+                                             WideStringView wsName) {
+  if (!parent)
+    return nullptr;
+  return FindFirstSiblingNamed(parent, FX_HashCode_GetW(wsName, false));
+}
+
+// static
+CXFA_Node* CXFA_NodeHelper::GetOneChildOfClass(CXFA_Node* parent,
+                                               WideStringView wsClass) {
+  if (!parent)
+    return nullptr;
+
+  XFA_Element element = XFA_GetElementByName(wsClass);
+  if (element == XFA_Element::Unknown)
+    return nullptr;
+
+  return FindFirstSiblingOfClass(parent, element);
+}
+
+// static
+int32_t CXFA_NodeHelper::CountSiblings(CXFA_Node* pNode,
+                                       XFA_LOGIC_TYPE eLogicType,
+                                       std::vector<CXFA_Node*>* pSiblings,
+                                       bool bIsClassName) {
+  if (!pNode)
+    return 0;
+  CXFA_Node* parent = GetParent(pNode, XFA_LOGIC_NoTransparent);
+  if (!parent)
+    return 0;
+  if (!parent->HasProperty(pNode->GetElementType()) &&
+      eLogicType == XFA_LOGIC_Transparent) {
+    parent = GetParent(pNode, XFA_LOGIC_Transparent);
+    if (!parent)
+      return 0;
+  }
+  if (bIsClassName) {
+    return TraverseSiblings(parent, pNode->GetClassHashCode(), pSiblings,
+                            eLogicType, bIsClassName, true);
+  }
+  return TraverseSiblings(parent, pNode->GetNameHash(), pSiblings, eLogicType,
+                          bIsClassName, true);
+}
+
+// static
 CXFA_Node* CXFA_NodeHelper::GetParent(CXFA_Node* pNode,
                                       XFA_LOGIC_TYPE eLogicType) {
-  if (!pNode) {
+  if (!pNode)
     return nullptr;
-  }
-  if (eLogicType == XFA_LOGIC_NoTransparent) {
+
+  if (eLogicType == XFA_LOGIC_NoTransparent)
     return pNode->GetParent();
-  }
+
   CXFA_Node* parent;
   CXFA_Node* node = pNode;
   while (true) {
     parent = GetParent(node, XFA_LOGIC_NoTransparent);
-    if (!parent) {
-      break;
-    }
+    if (!parent)
+      return nullptr;
+
     XFA_Element parentType = parent->GetElementType();
     if ((!parent->IsUnnamed() && parentType != XFA_Element::SubformSet) ||
         parentType == XFA_Element::Variables) {
@@ -205,6 +236,7 @@
   return parent;
 }
 
+// static
 int32_t CXFA_NodeHelper::GetIndex(CXFA_Node* pNode,
                                   XFA_LOGIC_TYPE eLogicType,
                                   bool bIsProperty,
@@ -234,38 +266,21 @@
   return 0;
 }
 
-WideString CXFA_NodeHelper::GetNameExpression(CXFA_Node* refNode,
-                                              bool bIsAllPath) {
-  WideString wsName;
-  if (bIsAllPath) {
-    wsName = GetNameExpression(refNode, false);
-    CXFA_Node* parent = GetParent(refNode, XFA_LOGIC_NoTransparent);
-    while (parent) {
-      WideString wsParent = GetNameExpression(parent, false);
-      wsParent += L".";
-      wsParent += wsName;
-      wsName = std::move(wsParent);
-      parent = GetParent(parent, XFA_LOGIC_NoTransparent);
-    }
-    return wsName;
+// static
+WideString CXFA_NodeHelper::GetNameExpression(CXFA_Node* refNode) {
+  WideString wsName = GetNameExpressionSinglePath(refNode);
+  CXFA_Node* parent = GetParent(refNode, XFA_LOGIC_NoTransparent);
+  while (parent) {
+    WideString wsParent = GetNameExpressionSinglePath(parent);
+    wsParent += L".";
+    wsParent += wsName;
+    wsName = std::move(wsParent);
+    parent = GetParent(parent, XFA_LOGIC_NoTransparent);
   }
-
-  WideString ws;
-  bool bIsProperty = NodeIsProperty(refNode);
-  if (refNode->IsUnnamed() ||
-      (bIsProperty && refNode->GetElementType() != XFA_Element::PageSet)) {
-    ws = WideString::FromASCII(refNode->GetClassName());
-    return WideString::Format(
-        L"#%ls[%d]", ws.c_str(),
-        GetIndex(refNode, XFA_LOGIC_Transparent, bIsProperty, true));
-  }
-  ws = refNode->JSObject()->GetCData(XFA_Attribute::Name);
-  ws.Replace(L".", L"\\.");
-  return WideString::Format(
-      L"%ls[%d]", ws.c_str(),
-      GetIndex(refNode, XFA_LOGIC_Transparent, bIsProperty, false));
+  return wsName;
 }
 
+// static
 bool CXFA_NodeHelper::NodeIsTransparent(CXFA_Node* refNode) {
   if (!refNode)
     return false;
@@ -388,6 +403,7 @@
   }
 }
 
+// static
 bool CXFA_NodeHelper::NodeIsProperty(CXFA_Node* refNode) {
   if (!refNode)
     return false;
diff --git a/xfa/fxfa/parser/cxfa_nodehelper.h b/xfa/fxfa/parser/cxfa_nodehelper.h
index 2ebde22..0deb0c0 100644
--- a/xfa/fxfa/parser/cxfa_nodehelper.h
+++ b/xfa/fxfa/parser/cxfa_nodehelper.h
@@ -26,27 +26,30 @@
   CXFA_NodeHelper();
   ~CXFA_NodeHelper();
 
-  CXFA_Node* GetOneChildNamed(CXFA_Node* parent, WideStringView wsName);
-  CXFA_Node* GetOneChildOfClass(CXFA_Node* parent, WideStringView wsClass);
+  static CXFA_Node* GetOneChildNamed(CXFA_Node* parent, WideStringView wsName);
+  static CXFA_Node* GetOneChildOfClass(CXFA_Node* parent,
+                                       WideStringView wsClass);
 
-  CXFA_Node* GetParent(CXFA_Node* pNode, XFA_LOGIC_TYPE eLogicType);
-  int32_t CountSiblings(CXFA_Node* pNode,
-                        XFA_LOGIC_TYPE eLogicType,
-                        std::vector<CXFA_Node*>* pSiblings,
-                        bool bIsClassName);
-  int32_t GetIndex(CXFA_Node* pNode,
-                   XFA_LOGIC_TYPE eLogicType,
-                   bool bIsProperty,
-                   bool bIsClassIndex);
-  WideString GetNameExpression(CXFA_Node* refNode, bool bIsAllPath);
-  bool NodeIsTransparent(CXFA_Node* refNode);
+  static CXFA_Node* GetParent(CXFA_Node* pNode, XFA_LOGIC_TYPE eLogicType);
+
+  static int32_t CountSiblings(CXFA_Node* pNode,
+                               XFA_LOGIC_TYPE eLogicType,
+                               std::vector<CXFA_Node*>* pSiblings,
+                               bool bIsClassName);
+  static int32_t GetIndex(CXFA_Node* pNode,
+                          XFA_LOGIC_TYPE eLogicType,
+                          bool bIsProperty,
+                          bool bIsClassIndex);
+  static WideString GetNameExpression(CXFA_Node* refNode);
+  static bool NodeIsTransparent(CXFA_Node* refNode);
+  static bool NodeIsProperty(CXFA_Node* refNode);
+
   bool CreateNode(const WideString& wsName,
                   const WideString& wsCondition,
                   bool bLastNode,
                   CFXJSE_Engine* pScriptContext);
   bool CreateNodeForCondition(const WideString& wsCondition);
   void SetCreateNodeType(CXFA_Node* refNode);
-  bool NodeIsProperty(CXFA_Node* refNode);
 
   XFA_Element m_eLastCreateType = XFA_Element::DataValue;
   XFA_ResolveNode_RSType m_iCreateFlag = XFA_ResolveNode_RSType_CreateNodeOne;
@@ -54,22 +57,6 @@
   int32_t m_iCurAllStart = -1;
   UnownedPtr<CXFA_Node> m_pCreateParent;
   UnownedPtr<CXFA_Node> m_pAllStartParent;
-
- private:
-  CXFA_Node* FindFirstSiblingNamed(CXFA_Node* parent, uint32_t dNameHash);
-  CXFA_Node* FindFirstSiblingNamedInList(CXFA_Node* parent,
-                                         uint32_t dwNameHash,
-                                         uint32_t dwFilter);
-  CXFA_Node* FindFirstSiblingOfClass(CXFA_Node* parent, XFA_Element element);
-  CXFA_Node* FindFirstSiblingOfClassInList(CXFA_Node* parent,
-                                           XFA_Element element,
-                                           uint32_t dwFilter);
-  int32_t TraverseSiblings(CXFA_Node* parent,
-                           uint32_t dNameHash,
-                           std::vector<CXFA_Node*>* pSiblings,
-                           XFA_LOGIC_TYPE eLogicType,
-                           bool bIsClassName,
-                           bool bIsFindProperty);
 };
 
 #endif  // XFA_FXFA_PARSER_CXFA_NODEHELPER_H_