Rename both As{Byte,Wide}StringC() helpers to AsStringC().

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 208 matching lines @@
   }
   wsNamespaceURI.Empty();
   return bRet;
 }
 static inline void XFA_FDEExtension_GetElementTagNamespaceURI(
     CFDE_XMLElement* pElement,
     CFX_WideString& wsNamespaceURI) {
   CFX_WideString wsNodeStr;
   pElement->GetNamespacePrefix(wsNodeStr);
   if (!XFA_FDEExtension_ResolveNamespaceQualifier(
-          pElement, wsNodeStr.AsWideStringC(), wsNamespaceURI)) {
+          pElement, wsNodeStr.AsStringC(), wsNamespaceURI)) {
     wsNamespaceURI.Empty();
   }
 }
 static FX_BOOL XFA_FDEExtension_MatchNodeName(
     CFDE_XMLNode* pNode,
     const CFX_WideStringC& wsLocalTagName,
     const CFX_WideStringC& wsNamespaceURIPrefix,
     uint32_t eMatchFlags = XFA_XDPPACKET_FLAGS_NOMATCH) {
   if (!pNode || pNode->GetType() != FDE_XMLNODE_Element) {
     return FALSE;
@@ skipping 37 matching lines @@
   if (XFA_FDEExtension_GetAttributeLocalName(wsAttributeName,
                                              wsLocalAttrName)) {
     wsNSPrefix = wsAttrName.Left(wsAttributeName.GetLength() -
                                  wsLocalAttrName.GetLength() - 1);
   }
   if (wsLocalAttrName == FX_WSTRC(L"xmlns") ||
       wsNSPrefix == FX_WSTRC(L"xmlns") || wsNSPrefix == FX_WSTRC(L"xml")) {
     return FALSE;
   }
   if (!XFA_FDEExtension_ResolveNamespaceQualifier(
-          pElement, wsNSPrefix.AsWideStringC(), wsNamespaceURI)) {
+          pElement, wsNSPrefix.AsStringC(), wsNamespaceURI)) {
     wsNamespaceURI.Empty();
     return FALSE;
   }
   return TRUE;
 }
 static FX_BOOL XFA_FDEExtension_FindAttributeWithNS(
     CFDE_XMLElement* pElement,
     const CFX_WideStringC& wsLocalAttributeName,
     const CFX_WideStringC& wsNamespaceURIPrefix,
     CFX_WideString& wsValue,
@@ skipping 14 matching lines @@
         continue;
       }
     } else {
       if (wsLocalAttributeName !=
           wsAttrName.Right(wsAttrName.GetLength() - iFind - 1)) {
         continue;
       }
       wsNSPrefix = wsAttrName.Left(iFind);
     }
     if (!XFA_FDEExtension_ResolveNamespaceQualifier(
-            pElement, wsNSPrefix.AsWideStringC(), wsAttrNS)) {
+            pElement, wsNSPrefix.AsStringC(), wsAttrNS)) {
       continue;
     }
     if (bMatchNSAsPrefix) {
       if (wsAttrNS.Left(wsNamespaceURIPrefix.GetLength()) !=
           wsNamespaceURIPrefix) {
         continue;
       }
     } else {
       if (wsAttrNS != wsNamespaceURIPrefix) {
         continue;
@@ skipping 94 matching lines @@
         continue;
       }
       if (pChildItem == pXMLConfigDOMRoot) {
         continue;
       }
       CFDE_XMLElement* pElement =
           reinterpret_cast<CFDE_XMLElement*>(pChildItem);
       CFX_WideString wsPacketName;
       pElement->GetLocalTagName(wsPacketName);
       const XFA_PACKETINFO* pPacketInfo =
-          XFA_GetPacketByName(wsPacketName.AsWideStringC());
+          XFA_GetPacketByName(wsPacketName.AsStringC());
       if (pPacketInfo && pPacketInfo->pURI) {
         if (!XFA_FDEExtension_MatchNodeName(pElement, pPacketInfo->pName,
                                             pPacketInfo->pURI,
                                             pPacketInfo->eFlags)) {
           pPacketInfo = nullptr;
         }
       }
       XFA_XDPPACKET ePacket =
           pPacketInfo ? pPacketInfo->eName : XFA_XDPPACKET_USER;
       if (ePacket == XFA_XDPPACKET_XDP) {
@@ skipping 131 matching lines @@
       if (bsCheck != wsChecksum.UTF8Encode()) {
         return NULL;
       }
 
       pNode = m_pFactory->CreateNode(XFA_XDPPACKET_Form, XFA_ELEMENT_Form);
       if (!pNode) {
         return NULL;
       }
       pNode->SetCData(XFA_ATTRIBUTE_Name,
                       XFA_GetPacketByIndex(XFA_PACKET_Form)->pName);
-      pNode->SetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum.AsWideStringC());
+      pNode->SetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum.AsStringC());
       CXFA_Node* pTemplateRoot =
           m_pRootNode->GetFirstChildByClass(XFA_ELEMENT_Template);
       CXFA_Node* pTemplateChosen =
           pTemplateRoot
               ? pTemplateRoot->GetFirstChildByClass(XFA_ELEMENT_Subform)
               : NULL;
       FX_BOOL bUseAttribute = TRUE;
       if (pTemplateChosen &&
           pTemplateChosen->GetEnum(XFA_ATTRIBUTE_RestoreState) !=
               XFA_ATTRIBUTEENUM_Auto) {
@@ skipping 216 matching lines @@
   FX_BOOL bOneOfPropertyFound = FALSE;
   for (CFDE_XMLNode* pXMLChild = pXMLDoc->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLChild;
        pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     switch (pXMLChild->GetType()) {
       case FDE_XMLNODE_Element: {
         CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLChild);
         CFX_WideString wsTagName;
         pXMLElement->GetLocalTagName(wsTagName);
         const XFA_ELEMENTINFO* pElemInfo =
-            XFA_GetElementByName(wsTagName.AsWideStringC());
+            XFA_GetElementByName(wsTagName.AsStringC());
         if (!pElemInfo) {
           continue;
         }
         const XFA_PROPERTY* pPropertyInfo = XFA_GetPropertyOfElement(
             pXFANode->GetClassID(), pElemInfo->eName, ePacketID);
         if (pPropertyInfo &&
             ((pPropertyInfo->uFlags &
               (XFA_PROPERTYFLAG_OneOf | XFA_PROPERTYFLAG_DefaultOneOf)) != 0)) {
           if (bOneOfPropertyFound) {
             break;
           }
           bOneOfPropertyFound = TRUE;
         }
         CXFA_Node* pXFAChild =
             m_pFactory->CreateNode(ePacketID, pElemInfo->eName);
         if (pXFAChild == NULL) {
           return NULL;
         }
         if (ePacketID == XFA_XDPPACKET_Config) {
-          pXFAChild->SetAttribute(XFA_ATTRIBUTE_Name,
-                                  wsTagName.AsWideStringC());
+          pXFAChild->SetAttribute(XFA_ATTRIBUTE_Name, wsTagName.AsStringC());
         }
         FX_BOOL IsNeedValue = TRUE;
         for (int32_t i = 0, count = pXMLElement->CountAttributes(); i < count;
              i++) {
           CFX_WideString wsAttrQualifiedName;
           CFX_WideString wsAttrName;
           CFX_WideString wsAttrValue;
           pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue);
           XFA_FDEExtension_GetAttributeLocalName(
-              wsAttrQualifiedName.AsWideStringC(), wsAttrName);
+              wsAttrQualifiedName.AsStringC(), wsAttrName);
           if (wsAttrName == FX_WSTRC(L"nil") &&
               wsAttrValue == FX_WSTRC(L"true")) {
             IsNeedValue = FALSE;
           }
           const XFA_ATTRIBUTEINFO* lpAttrInfo =
-              XFA_GetAttributeByName(wsAttrName.AsWideStringC());
+              XFA_GetAttributeByName(wsAttrName.AsStringC());
           if (!lpAttrInfo) {
             continue;
           }
           if (!bUseAttribute && lpAttrInfo->eName != XFA_ATTRIBUTE_Name &&
               lpAttrInfo->eName != XFA_ATTRIBUTE_Save) {
             continue;
           }
-          pXFAChild->SetAttribute(lpAttrInfo->eName,
-                                  wsAttrValue.AsWideStringC());
+          pXFAChild->SetAttribute(lpAttrInfo->eName, wsAttrValue.AsStringC());
         }
         pXFANode->InsertChild(pXFAChild);
         if (pElemInfo->eName == XFA_ELEMENT_Validate ||
             pElemInfo->eName == XFA_ELEMENT_Locale) {
           if (ePacketID == XFA_XDPPACKET_Config) {
             ParseContentNode(pXFAChild, pXMLElement, ePacketID);
           } else {
             NormalLoader(pXFAChild, pXMLElement, ePacketID, bUseAttribute);
           }
           break;
@@ skipping 222 matching lines @@
         FX_BOOL bNeedValue = TRUE;
         if (1) {
           for (int32_t i = 0, count = pXMLElement->CountAttributes(); i < count;
                i++) {
             CFX_WideString wsAttrQualifiedName;
             CFX_WideString wsAttrValue;
             CFX_WideString wsAttrName;
             CFX_WideString wsAttrNamespaceURI;
             pXMLElement->GetAttribute(i, wsAttrQualifiedName, wsAttrValue);
             if (!XFA_FDEExtension_ResolveAttribute(
-                    pXMLElement, wsAttrQualifiedName.AsWideStringC(),
-                    wsAttrName, wsAttrNamespaceURI)) {
+                    pXMLElement, wsAttrQualifiedName.AsStringC(), wsAttrName,
+                    wsAttrNamespaceURI)) {
               continue;
             }
             if (wsAttrName == FX_WSTRC(L"nil") &&
                 wsAttrValue == FX_WSTRC(L"true")) {
               bNeedValue = FALSE;
               continue;
             }
             if (wsAttrNamespaceURI ==
                     FX_WSTRC(L"http://www.xfa.com/schema/xfa-package/") ||
                 wsAttrNamespaceURI ==
@@ skipping 432 matching lines @@
     }
     if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return (m_syntaxParserResult == FDE_XmlSyntaxResult::Error ||
           m_NodeStack.GetSize() != 1)
              ? -1
              : m_pParser->GetStatus();
 }