Cleanup redundant method names.

xfa/fxfa/parser/xfa_script_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_script_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "fxjse/include/cfxjse_arguments.h"
@@ skipping 527 matching lines @@
   if (m_eScriptType != XFA_SCRIPTLANGTYPE_Formcalc ||
       (dwStyles & (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings))) {
     m_upObjectArray.RemoveAll();
   }
   if (refNode && refNode->IsNode() &&
       (dwStyles & (XFA_RESOLVENODE_Parent | XFA_RESOLVENODE_Siblings))) {
     m_upObjectArray.Add(refNode->AsNode());
   }
   FX_BOOL bNextCreate = FALSE;
   if (dwStyles & XFA_RESOLVENODE_CreateNode) {
-    m_ResolveProcessor->GetNodeHelper()->XFA_SetCreateNodeType(bindNode);
+    m_ResolveProcessor->GetNodeHelper()->SetCreateNodeType(bindNode);
   }
   m_ResolveProcessor->GetNodeHelper()->m_pCreateParent = nullptr;
   m_ResolveProcessor->GetNodeHelper()->m_iCurAllStart = -1;
   CXFA_ResolveNodesData rndFind;
   int32_t nStart = 0;
   int32_t nLevel = 0;
   int32_t nRet = -1;
   rndFind.m_pSC = this;
   CXFA_ObjArray findNodes;
   findNodes.Add(refNode ? refNode : m_pDocument->GetRoot());
   int32_t nNodes = 0;
   while (TRUE) {
     nNodes = findNodes.GetSize();
     int32_t i = 0;
     rndFind.m_dwStyles = dwStyles;
-    m_ResolveProcessor->m_iCurStart = nStart;
-    nStart = m_ResolveProcessor->XFA_ResolveNodes_GetFilter(wsExpression,
-                                                            nStart, rndFind);
+    m_ResolveProcessor->SetCurStart(nStart);
+    nStart = m_ResolveProcessor->GetFilter(wsExpression, nStart, rndFind);
     if (nStart < 1) {
       if ((dwStyles & XFA_RESOLVENODE_CreateNode) && !bNextCreate) {
         CXFA_Node* pDataNode = nullptr;
         nStart = m_ResolveProcessor->GetNodeHelper()->m_iCurAllStart;
         if (nStart != -1) {
           pDataNode = m_pDocument->GetNotBindNode(findNodes);
           if (pDataNode) {
             findNodes.RemoveAll();
             findNodes.Add(pDataNode);
             break;
           }
         } else {
           pDataNode = findNodes[0]->AsNode();
           findNodes.RemoveAll();
           findNodes.Add(pDataNode);
           break;
         }
         dwStyles |= XFA_RESOLVENODE_Bind;
         findNodes.RemoveAll();
         findNodes.Add(m_ResolveProcessor->GetNodeHelper()->m_pAllStartParent);
         continue;
       } else {
         break;
       }
     }
     if (bNextCreate) {
       FX_BOOL bCreate =
-          m_ResolveProcessor->GetNodeHelper()->XFA_ResolveNodes_CreateNode(
+          m_ResolveProcessor->GetNodeHelper()->ResolveNodes_CreateNode(
               rndFind.m_wsName, rndFind.m_wsCondition,
               nStart == wsExpression.GetLength(), this);
       if (bCreate) {
         continue;
       } else {
         break;
       }
     }
     CXFA_ObjArray retNodes;
     while (i < nNodes) {
       FX_BOOL bDataBind = FALSE;
       if (((dwStyles & XFA_RESOLVENODE_Bind) ||
            (dwStyles & XFA_RESOLVENODE_CreateNode)) &&
           nNodes > 1) {
         CXFA_ResolveNodesData rndBind;
-        m_ResolveProcessor->XFA_ResolveNodes_GetFilter(wsExpression, nStart,
-                                                       rndBind);
-        m_ResolveProcessor->XFA_ResolveNode_SetIndexDataBind(
-            rndBind.m_wsCondition, i, nNodes);
+        m_ResolveProcessor->GetFilter(wsExpression, nStart, rndBind);
+        m_ResolveProcessor->SetIndexDataBind(rndBind.m_wsCondition, i, nNodes);
         bDataBind = TRUE;
       }
       rndFind.m_CurNode = findNodes[i++];
       rndFind.m_nLevel = nLevel;
       rndFind.m_dwFlag = XFA_RESOVENODE_RSTYPE_Nodes;
-      nRet = m_ResolveProcessor->XFA_ResolveNodes(rndFind);
+      nRet = m_ResolveProcessor->Resolve(rndFind);
       if (nRet < 1) {
         continue;
       }
       if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute &&
           rndFind.m_pScriptAttribute && nStart < wsExpression.GetLength()) {
         std::unique_ptr<CFXJSE_Value> pValue(new CFXJSE_Value(m_pIsolate));
         (rndFind.m_Nodes[0]->*(rndFind.m_pScriptAttribute->lpfnCallback))(
             pValue.get(), FALSE,
             (XFA_ATTRIBUTE)rndFind.m_pScriptAttribute->eAttribute);
         rndFind.m_Nodes.SetAt(0, ToObject(pValue.get(), nullptr));
@@ skipping 12 matching lines @@
     nNodes = retNodes.GetSize();
     if (nNodes < 1) {
       if (dwStyles & XFA_RESOLVENODE_CreateNode) {
         bNextCreate = TRUE;
         if (!m_ResolveProcessor->GetNodeHelper()->m_pCreateParent) {
           m_ResolveProcessor->GetNodeHelper()->m_pCreateParent =
               ToNode(rndFind.m_CurNode);
           m_ResolveProcessor->GetNodeHelper()->m_iCreateCount = 1;
         }
         FX_BOOL bCreate =
-            m_ResolveProcessor->GetNodeHelper()->XFA_ResolveNodes_CreateNode(
+            m_ResolveProcessor->GetNodeHelper()->ResolveNodes_CreateNode(
                 rndFind.m_wsName, rndFind.m_wsCondition,
                 nStart == wsExpression.GetLength(), this);
         if (bCreate) {
           continue;
         } else {
           break;
         }
       } else {
         break;
       }
@@ skipping 10 matching lines @@
     if (nNodes > 0) {
       resolveNodeRS.nodes.Append(findNodes);
     }
     if (rndFind.m_dwFlag == XFA_RESOVENODE_RSTYPE_Attribute) {
       resolveNodeRS.pScriptAttribute = rndFind.m_pScriptAttribute;
       return 1;
     }
   }
   if (dwStyles & (XFA_RESOLVENODE_CreateNode | XFA_RESOLVENODE_Bind |
                   XFA_RESOLVENODE_BindNew)) {
-    m_ResolveProcessor->XFA_ResolveNode_SetResultCreateNode(
-        resolveNodeRS, rndFind.m_wsCondition);
+    m_ResolveProcessor->SetResultCreateNode(resolveNodeRS,
+                                            rndFind.m_wsCondition);
     if (!bNextCreate && (dwStyles & XFA_RESOLVENODE_CreateNode)) {
       resolveNodeRS.dwFlags = XFA_RESOVENODE_RSTYPE_ExistNodes;
     }
     return resolveNodeRS.nodes.GetSize();
   }
   return nNodes;
 }
 
 void CXFA_ScriptContext::AddToCacheList(std::unique_ptr<CXFA_NodeList> pList) {
   m_CacheList.push_back(std::move(pList));
@@ skipping 10 matching lines @@
     return iter->second.get();
 
   std::unique_ptr<CFXJSE_Value> jsValue(new CFXJSE_Value(m_pIsolate));
   jsValue->SetObject(pObject, m_pJsClass);
   CFXJSE_Value* pValue = jsValue.get();
   m_mapObjectToValue.insert(std::make_pair(pObject, std::move(jsValue)));
   return pValue;
 }
 int32_t CXFA_ScriptContext::GetIndexByName(CXFA_Node* refNode) {
   CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
-  return lpNodeHelper->XFA_GetIndex(refNode, XFA_LOGIC_Transparent,
-                                    lpNodeHelper->XFA_NodeIsProperty(refNode),
-                                    FALSE);
+  return lpNodeHelper->GetIndex(refNode, XFA_LOGIC_Transparent,
+                                lpNodeHelper->NodeIsProperty(refNode), FALSE);
 }
 int32_t CXFA_ScriptContext::GetIndexByClassName(CXFA_Node* refNode) {
   CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
-  return lpNodeHelper->XFA_GetIndex(refNode, XFA_LOGIC_Transparent,
-                                    lpNodeHelper->XFA_NodeIsProperty(refNode),
-                                    TRUE);
+  return lpNodeHelper->GetIndex(refNode, XFA_LOGIC_Transparent,
+                                lpNodeHelper->NodeIsProperty(refNode), TRUE);
 }
 void CXFA_ScriptContext::GetSomExpression(CXFA_Node* refNode,
                                           CFX_WideString& wsExpression) {
   CXFA_NodeHelper* lpNodeHelper = m_ResolveProcessor->GetNodeHelper();
-  lpNodeHelper->XFA_GetNameExpression(refNode, wsExpression, TRUE,
-                                      XFA_LOGIC_Transparent);
+  lpNodeHelper->GetNameExpression(refNode, wsExpression, TRUE,
+                                  XFA_LOGIC_Transparent);
 }
 void CXFA_ScriptContext::SetNodesOfRunScript(CXFA_NodeArray* pArray) {
   m_pScriptNodeArray = pArray;
 }
 void CXFA_ScriptContext::AddNodesOfRunScript(const CXFA_NodeArray& nodes) {
   if (!m_pScriptNodeArray)
     return;
   if (nodes.GetSize() > 0)
     m_pScriptNodeArray->Copy(nodes);
 }
 void CXFA_ScriptContext::AddNodesOfRunScript(CXFA_Node* pNode) {
   if (!m_pScriptNodeArray)
     return;
   if (m_pScriptNodeArray->Find(pNode) == -1)
     m_pScriptNodeArray->Add(pNode);
 }