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

xfa/fxfa/parser/xfa_object_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_object.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
@@ skipping 39 matching lines @@
   ASSERT(FALSE);
   return (XFA_ELEMENT)0;
 }
 void CXFA_Object::Script_ObjectClass_ClassName(FXJSE_HVALUE hValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC className;
     GetClassName(className);
     FXJSE_Value_SetUTF8String(
-        hValue, FX_UTF8Encode(className.c_str(), className.GetLength())
-                    .AsByteStringC());
+        hValue,
+        FX_UTF8Encode(className.c_str(), className.GetLength()).AsStringC());
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Object::ThrowScriptErrorMessage(int32_t iStringID, ...) {
   IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
   FXSYS_assert(pAppProvider);
   CFX_WideString wsFormat;
   pAppProvider->LoadString(iStringID, wsFormat);
   CFX_WideString wsMessage;
   va_list arg_ptr;
   va_start(arg_ptr, iStringID);
   wsMessage.FormatV((const FX_WCHAR*)wsFormat, arg_ptr);
   va_end(arg_ptr);
   FXJSE_ThrowMessage(
-      "", FX_UTF8Encode(wsMessage, wsMessage.GetLength()).AsByteStringC());
+      "", FX_UTF8Encode(wsMessage, wsMessage.GetLength()).AsStringC());
 }
 
 static void XFA_DeleteWideString(void* pData) {
   delete static_cast<CFX_WideString*>(pData);
 }
 
 static void XFA_CopyWideString(void*& pData) {
   if (pData) {
     CFX_WideString* pNewData = new CFX_WideString(*(CFX_WideString*)pData);
     pData = pNewData;
@@ skipping 539 matching lines @@
   FXSYS_assert(m_ePacket == XFA_XDPPACKET_Datasets);
   m_pAuxNode = pDataDescriptionNode;
 }
 void CXFA_Node::Script_TreeClass_ResolveNode(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"resolveNode");
     return;
   }
   CFX_WideString wsExpression =
-      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsByteStringC());
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   CXFA_Node* refNode = this;
   if (refNode->GetClassID() == XFA_ELEMENT_Xfa) {
     refNode = ToNode(pScriptContext->GetThisObject());
   }
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   XFA_RESOLVENODE_RS resoveNodeRS;
   int32_t iRet = pScriptContext->ResolveObjects(
-      refNode, wsExpression.AsWideStringC(), resoveNodeRS, dwFlag);
+      refNode, wsExpression.AsStringC(), resoveNodeRS, dwFlag);
   if (iRet < 1) {
     return FXJSE_Value_SetNull(pArguments->GetReturnValue());
   }
   FXJSE_HVALUE hValue = NULL;
   if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
     CXFA_Object* pNode = resoveNodeRS.nodes[0];
     hValue = pScriptContext->GetJSValueFromMap(pNode);
     FXJSE_Value_Set(pArguments->GetReturnValue(), hValue);
   } else {
     const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo =
@@ skipping 10 matching lines @@
   }
 }
 void CXFA_Node::Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"resolveNodes");
     return;
   }
   CFX_WideString wsExpression =
-      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsByteStringC());
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (!hValue) {
     return;
   }
   uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                     XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                     XFA_RESOLVENODE_Siblings;
   CXFA_Node* refNode = this;
   if (refNode->GetClassID() == XFA_ELEMENT_Xfa) {
     refNode = ToNode(m_pDocument->GetScriptContext()->GetThisObject());
   }
   Script_Som_ResolveNodeList(hValue, wsExpression, dwFlag, refNode);
 }
 void CXFA_Node::Script_Som_ResolveNodeList(FXJSE_HVALUE hValue,
                                            CFX_WideString wsExpression,
                                            uint32_t dwFlag,
                                            CXFA_Node* refNode) {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   XFA_RESOLVENODE_RS resoveNodeRS;
   if (refNode == NULL) {
     refNode = this;
   }
-  pScriptContext->ResolveObjects(refNode, wsExpression.AsWideStringC(),
+  pScriptContext->ResolveObjects(refNode, wsExpression.AsStringC(),
                                  resoveNodeRS, dwFlag);
   CXFA_ArrayNodeList* pNodeList = new CXFA_ArrayNodeList(m_pDocument);
   if (resoveNodeRS.dwFlags == XFA_RESOVENODE_RSTYPE_Nodes) {
     for (int32_t i = 0; i < resoveNodeRS.nodes.GetSize(); i++) {
       if (resoveNodeRS.nodes[i]->IsNode())
         pNodeList->Append(resoveNodeRS.nodes[i]->AsNode());
     }
   } else {
     CXFA_HVALUEArray hValueArray(pScriptContext->GetRuntime());
     if (resoveNodeRS.GetAttributeResult(hValueArray) > 0) {
@@ skipping 27 matching lines @@
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext) {
     return;
   }
   if (bSetting) {
     IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
     FXSYS_assert(pAppProvider);
     CFX_WideString wsMessage;
     pAppProvider->LoadString(XFA_IDS_Unable_TO_SET, wsMessage);
     FXJSE_ThrowMessage(
-        "", FX_UTF8Encode(wsMessage, wsMessage.GetLength()).AsByteStringC());
+        "", FX_UTF8Encode(wsMessage, wsMessage.GetLength()).AsStringC());
   } else {
     CXFA_AttachNodeList* pNodeList = new CXFA_AttachNodeList(m_pDocument, this);
     FXJSE_Value_SetObject(hValue, (CXFA_Object*)pNodeList,
                           pScriptContext->GetJseNormalClass());
   }
 }
 void CXFA_Node::Script_TreeClass_ClassAll(FXJSE_HVALUE hValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
@@ skipping 41 matching lines @@
 }
 void CXFA_Node::Script_TreeClass_SomExpression(FXJSE_HVALUE hValue,
                                                FX_BOOL bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsSOMExpression;
     GetSOMExpression(wsSOMExpression);
     FXJSE_Value_SetUTF8String(hValue,
-                              FX_UTF8Encode(wsSOMExpression).AsByteStringC());
+                              FX_UTF8Encode(wsSOMExpression).AsStringC());
   }
 }
 void CXFA_Node::Script_NodeClass_ApplyXSL(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"applyXSL");
     return;
   }
   CFX_WideString wsExpression =
-      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsByteStringC());
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   // TODO(tsepez): actually do something here?
 }
 void CXFA_Node::Script_NodeClass_AssignNode(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"assignNode");
     return;
   }
   CFX_WideString wsExpression;
   CFX_WideString wsValue;
   int32_t iAction = 0;
   if (iLength >= 1) {
     CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsByteStringC());
+    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsStringC());
   }
   if (iLength >= 2) {
     CFX_ByteString bsValue = pArguments->GetUTF8String(1);
-    wsValue = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
   }
   if (iLength >= 3) {
     iAction = pArguments->GetInt32(2);
   }
 }
 void CXFA_Node::Script_NodeClass_Clone(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"clone");
     return;
   }
   FX_BOOL bClone = TRUE;
   bClone = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
   CXFA_Node* pCloneNode = Clone(bClone);
   FXJSE_Value_Set(
       pArguments->GetReturnValue(),
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pCloneNode));
 }
 void CXFA_Node::Script_NodeClass_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"getAttribute");
     return;
   }
   CFX_WideString wsExpression =
-      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsByteStringC());
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFX_WideString wsValue;
-  GetAttribute(wsExpression.AsWideStringC(), wsValue);
+  GetAttribute(wsExpression.AsStringC(), wsValue);
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsStringC());
   }
 }
 void CXFA_Node::Script_NodeClass_GetElement(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getElement");
     return;
   }
   CFX_WideString wsExpression;
   int32_t iValue = 0;
   if (iLength >= 1) {
     CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsByteStringC());
+    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsStringC());
   }
   if (iLength >= 2) {
     iValue = pArguments->GetInt32(1);
   }
   const XFA_ELEMENTINFO* pElementInfo =
-      XFA_GetElementByName(wsExpression.AsWideStringC());
+      XFA_GetElementByName(wsExpression.AsStringC());
   CXFA_Node* pNode = GetProperty(iValue, pElementInfo->eName);
   FXJSE_Value_Set(pArguments->GetReturnValue(),
                   m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
 }
 void CXFA_Node::Script_NodeClass_IsPropertySpecified(
     CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"isPropertySpecified");
     return;
   }
   CFX_WideString wsExpression;
   FX_BOOL bParent = TRUE;
   int32_t iIndex = 0;
   if (iLength >= 1) {
     CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsByteStringC());
+    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsStringC());
   }
   if (iLength >= 2) {
     bParent = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
   }
   if (iLength >= 3) {
     iIndex = pArguments->GetInt32(2);
   }
   FX_BOOL bHas = FALSE;
   const XFA_ATTRIBUTEINFO* pAttributeInfo =
-      XFA_GetAttributeByName(wsExpression.AsWideStringC());
+      XFA_GetAttributeByName(wsExpression.AsStringC());
   CFX_WideString wsValue;
   if (pAttributeInfo) {
     bHas = HasAttribute(pAttributeInfo->eName);
   }
   if (!bHas) {
     const XFA_ELEMENTINFO* pElementInfo =
-        XFA_GetElementByName(wsExpression.AsWideStringC());
+        XFA_GetElementByName(wsExpression.AsStringC());
     bHas = (GetProperty(iIndex, pElementInfo->eName) != NULL);
   }
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
     FXJSE_Value_SetBoolean(hValue, bHas);
   }
 }
 void CXFA_Node::Script_NodeClass_LoadXML(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 3) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"loadXML");
     return;
   }
   CFX_WideString wsExpression;
   FX_BOOL bIgnoreRoot = TRUE;
   FX_BOOL bOverwrite = 0;
   if (iLength >= 1) {
     CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
-    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsByteStringC());
+    wsExpression = CFX_WideString::FromUTF8(bsExpression.AsStringC());
     if (wsExpression.IsEmpty()) {
       return;
     }
   }
   if (iLength >= 2) {
     bIgnoreRoot = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
   }
   if (iLength >= 3) {
     bOverwrite = pArguments->GetInt32(2) == 0 ? FALSE : TRUE;
   }
@@ skipping 176 matching lines @@
 }
 
 void CXFA_Node::Script_NodeClass_SetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"setAttribute");
     return;
   }
   CFX_WideString wsAttributeValue =
-      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsByteStringC());
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   CFX_WideString wsAttribute =
-      CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsByteStringC());
-  SetAttribute(wsAttribute.AsWideStringC(), wsAttributeValue.AsWideStringC(),
-               TRUE);
+      CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC());
+  SetAttribute(wsAttribute.AsStringC(), wsAttributeValue.AsStringC(), TRUE);
 }
 void CXFA_Node::Script_NodeClass_SetElement(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1 && iLength != 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setElement");
     return;
   }
   CXFA_Node* pNode = NULL;
   CFX_WideString wsName;
   if (iLength >= 1) {
     pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
   }
   if (iLength >= 2) {
     CFX_ByteString bsName = pArguments->GetUTF8String(1);
-    wsName = CFX_WideString::FromUTF8(bsName.AsByteStringC());
+    wsName = CFX_WideString::FromUTF8(bsName.AsStringC());
   }
 }
 void CXFA_Node::Script_NodeClass_Ns(FXJSE_HVALUE hValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsNameSpace;
     TryNamespace(wsNameSpace);
-    FXJSE_Value_SetUTF8String(hValue,
-                              FX_UTF8Encode(wsNameSpace).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsNameSpace).AsStringC());
   }
 }
 void CXFA_Node::Script_NodeClass_Model(FXJSE_HVALUE hValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   } else {
     FXJSE_Value_Set(hValue, m_pDocument->GetScriptContext()->GetJSValueFromMap(
                                 GetModelNode()));
@@ skipping 51 matching lines @@
 void CXFA_Node::Script_ModelClass_IsCompatibleNS(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"isCompatibleNS");
     return;
   }
   CFX_WideString wsNameSpace;
   if (iLength >= 1) {
     CFX_ByteString bsNameSpace = pArguments->GetUTF8String(0);
-    wsNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsByteStringC());
+    wsNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC());
   }
   CFX_WideString wsNodeNameSpace;
   TryNamespace(wsNodeNameSpace);
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
     FXJSE_Value_SetBoolean(hValue, wsNodeNameSpace == wsNameSpace);
   }
 }
 void CXFA_Node::Script_ModelClass_Context(FXJSE_HVALUE hValue,
                                           FX_BOOL bSetting,
@@ skipping 202 matching lines @@
     pNotify->OnNodeEvent(this, XFA_NODEEVENT_ValueChanged, eAttribute, eValue,
                          this, this);
   }
 }
 void CXFA_Node::Script_Attribute_String(FXJSE_HVALUE hValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString szValue;
     FXJSE_Value_ToUTF8String(hValue, szValue);
-    CFX_WideString wsValue = CFX_WideString::FromUTF8(szValue.AsByteStringC());
-    SetAttribute(eAttribute, wsValue.AsWideStringC(), TRUE);
+    CFX_WideString wsValue = CFX_WideString::FromUTF8(szValue.AsStringC());
+    SetAttribute(eAttribute, wsValue.AsStringC(), TRUE);
     if (eAttribute == XFA_ATTRIBUTE_Use && GetClassID() == XFA_ELEMENT_Desc) {
       CFX_WideString wsUseVal = wsValue, wsID, wsSOM;
       CXFA_Node* pTemplateNode =
           ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
       CXFA_Node* pProtoRoot =
           pTemplateNode->GetFirstChildByClass(XFA_ELEMENT_Subform)
               ->GetFirstChildByClass(XFA_ELEMENT_Proto);
       if (!wsUseVal.IsEmpty()) {
         if (wsUseVal[0] == '#') {
           wsID = CFX_WideString((const FX_WCHAR*)wsUseVal + 1,
                                 wsUseVal.GetLength() - 1);
         } else {
           wsSOM =
               CFX_WideString((const FX_WCHAR*)wsUseVal, wsUseVal.GetLength());
         }
       }
       CXFA_Node* pProtoNode = NULL;
       if (!wsSOM.IsEmpty()) {
         uint32_t dwFlag = XFA_RESOLVENODE_Children |
                           XFA_RESOLVENODE_Attributes |
                           XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                           XFA_RESOLVENODE_Siblings;
         XFA_RESOLVENODE_RS resoveNodeRS;
         int32_t iRet = m_pDocument->GetScriptContext()->ResolveObjects(
-            pProtoRoot, wsSOM.AsWideStringC(), resoveNodeRS, dwFlag);
+            pProtoRoot, wsSOM.AsStringC(), resoveNodeRS, dwFlag);
         if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) {
           pProtoNode = resoveNodeRS.nodes[0]->AsNode();
         }
       } else if (!wsID.IsEmpty()) {
-        pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID.AsWideStringC());
+        pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID.AsStringC());
       }
       if (pProtoNode) {
         CXFA_Node* pHeadChild = GetNodeItem(XFA_NODEITEM_FirstChild);
         while (pHeadChild) {
           CXFA_Node* pSibling =
               pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling);
           RemoveChild(pHeadChild);
           pHeadChild = pSibling;
         }
         CXFA_Node* pProtoForm = pProtoNode->CloneTemplateToForm(TRUE);
         pHeadChild = pProtoForm->GetNodeItem(XFA_NODEITEM_FirstChild);
         while (pHeadChild) {
           CXFA_Node* pSibling =
               pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling);
           pProtoForm->RemoveChild(pHeadChild);
           InsertChild(pHeadChild);
           pHeadChild = pSibling;
         }
         m_pDocument->RemovePurgeNode(pProtoForm);
         delete pProtoForm;
       }
     }
   } else {
     CFX_WideString wsValue;
     GetAttribute(eAttribute, wsValue);
     FXJSE_Value_SetUTF8String(
-        hValue, FX_UTF8Encode(wsValue, wsValue.GetLength()).AsByteStringC());
+        hValue, FX_UTF8Encode(wsValue, wsValue.GetLength()).AsStringC());
   }
 }
 void CXFA_Node::Script_Attribute_StringRead(FXJSE_HVALUE hValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideString wsValue;
     GetAttribute(eAttribute, wsValue);
     FXJSE_Value_SetUTF8String(
-        hValue, FX_UTF8Encode(wsValue, wsValue.GetLength()).AsByteStringC());
+        hValue, FX_UTF8Encode(wsValue, wsValue.GetLength()).AsStringC());
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Node::Script_WsdlConnection_Execute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc == 0) || (argc == 1)) {
     FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execute");
@@ skipping 27 matching lines @@
   if (!validate) {
     validate = pWidgetData->GetValidate(TRUE);
     bNew = TRUE;
   }
   if (bSetting) {
     CFX_ByteString bsMessage;
     FXJSE_Value_ToUTF8String(hValue, bsMessage);
     switch (iMessageType) {
       case XFA_SOM_ValidationMessage:
         validate.SetScriptMessageText(
-            CFX_WideString::FromUTF8(bsMessage.AsByteStringC()));
+            CFX_WideString::FromUTF8(bsMessage.AsStringC()));
         break;
       case XFA_SOM_FormatMessage:
         validate.SetFormatMessageText(
-            CFX_WideString::FromUTF8(bsMessage.AsByteStringC()));
+            CFX_WideString::FromUTF8(bsMessage.AsStringC()));
         break;
       case XFA_SOM_MandatoryMessage:
         validate.SetNullMessageText(
-            CFX_WideString::FromUTF8(bsMessage.AsByteStringC()));
+            CFX_WideString::FromUTF8(bsMessage.AsStringC()));
         break;
       default:
         break;
     }
     if (!bNew) {
       CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
       if (!pNotify) {
         return;
       }
       pNotify->AddCalcValidate(this);
     }
   } else {
     CFX_WideString wsMessage;
     switch (iMessageType) {
       case XFA_SOM_ValidationMessage:
         validate.GetScriptMessageText(wsMessage);
         break;
       case XFA_SOM_FormatMessage:
         validate.GetFormatMessageText(wsMessage);
         break;
       case XFA_SOM_MandatoryMessage:
         validate.GetNullMessageText(wsMessage);
         break;
       default:
         break;
     }
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsMessage).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsMessage).AsStringC());
   }
 }
 void CXFA_Node::Script_Som_ValidationMessage(FXJSE_HVALUE hValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(hValue, bSetting, XFA_SOM_ValidationMessage);
 }
 void CXFA_Node::Script_Field_Length(FXJSE_HVALUE hValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
@@ skipping 20 matching lines @@
     return;
   } else if (classID == XFA_ELEMENT_Boolean) {
     Script_Boolean_Value(hValue, bSetting, eAttribute);
     return;
   }
   if (bSetting) {
     CFX_ByteString newValue;
     if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
       FXJSE_Value_ToUTF8String(hValue, newValue);
     }
-    CFX_WideString wsNewValue =
-        CFX_WideString::FromUTF8(newValue.AsByteStringC());
+    CFX_WideString wsNewValue = CFX_WideString::FromUTF8(newValue.AsStringC());
     CFX_WideString wsFormatValue(wsNewValue);
     CXFA_WidgetData* pContainerWidgetData = NULL;
     if (GetPacketID() == XFA_XDPPACKET_Datasets) {
       CXFA_NodeArray formNodes;
       GetBindItems(formNodes);
       CFX_WideString wsPicture;
       for (int32_t i = 0; i < formNodes.GetSize(); i++) {
         CXFA_Node* pFormNode = formNodes.GetAt(i);
         if (!pFormNode || pFormNode->HasFlag(XFA_NODEFLAG_HasRemoved)) {
           continue;
         }
         pContainerWidgetData = pFormNode->GetContainerWidgetData();
         if (pContainerWidgetData) {
           pContainerWidgetData->GetPictureContent(wsPicture,
                                                   XFA_VALUEPICTURE_DataBind);
         }
         if (!wsPicture.IsEmpty()) {
           break;
         }
         pContainerWidgetData = NULL;
       }
     } else if (GetPacketID() == XFA_XDPPACKET_Form) {
       pContainerWidgetData = GetContainerWidgetData();
     }
     if (pContainerWidgetData) {
-      pContainerWidgetData->GetFormatDataValue(wsNewValue.AsWideStringC(),
+      pContainerWidgetData->GetFormatDataValue(wsNewValue.AsStringC(),
                                                wsFormatValue);
     }
     SetScriptContent(wsNewValue, wsFormatValue, TRUE, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty() && classID != XFA_ELEMENT_Text &&
         classID != XFA_ELEMENT_SubmitUrl) {
       FXJSE_Value_SetNull(hValue);
     } else if (classID == XFA_ELEMENT_Integer) {
       FXJSE_Value_SetInteger(hValue, FXSYS_wtoi(content));
     } else if (classID == XFA_ELEMENT_Float || classID == XFA_ELEMENT_Decimal) {
-      CFX_Decimal decimal(content.AsWideStringC());
+      CFX_Decimal decimal(content.AsStringC());
       FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
     } else {
       FXJSE_Value_SetUTF8String(
-          hValue, FX_UTF8Encode(content, content.GetLength()).AsByteStringC());
+          hValue, FX_UTF8Encode(content, content.GetLength()).AsStringC());
     }
   }
 }
 void CXFA_Node::Script_Som_DefaultValue_Read(FXJSE_HVALUE hValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CFX_WideString content = GetScriptContent(TRUE);
   if (content.IsEmpty()) {
     FXJSE_Value_SetNull(hValue);
   } else {
     FXJSE_Value_SetUTF8String(
-        hValue, FX_UTF8Encode(content, content.GetLength()).AsByteStringC());
+        hValue, FX_UTF8Encode(content, content.GetLength()).AsStringC());
   }
 }
 void CXFA_Node::Script_Boolean_Value(FXJSE_HVALUE hValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString newValue;
     if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
       FXJSE_Value_ToUTF8String(hValue, newValue);
     }
     int32_t iValue = FXSYS_atoi(newValue);
     CFX_WideString wsNewValue = (iValue == 0) ? FX_WSTRC(L"0") : FX_WSTRC(L"1");
     CFX_WideString wsFormatValue(wsNewValue);
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     if (pContainerWidgetData) {
-      pContainerWidgetData->GetFormatDataValue(wsNewValue.AsWideStringC(),
+      pContainerWidgetData->GetFormatDataValue(wsNewValue.AsStringC(),
                                                wsFormatValue);
     }
     SetScriptContent(wsNewValue, wsFormatValue, TRUE, TRUE);
   } else {
     CFX_WideString wsValue = GetScriptContent(TRUE);
     FXJSE_Value_SetBoolean(hValue, wsValue == FX_WSTRC(L"1"));
   }
 }
 struct XFA_ExecEventParaInfo {
  public:
@@ skipping 90 matching lines @@
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Border border = pWidgetData->GetBorder(TRUE);
   int32_t iSize = border.CountEdges();
   CFX_WideString strColor;
   if (bSetting) {
     CFX_ByteString bsValue;
     FXJSE_Value_ToUTF8String(hValue, bsValue);
-    strColor = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    strColor = CFX_WideString::FromUTF8(bsValue.AsStringC());
     int32_t r = 0, g = 0, b = 0;
     XFA_STRING_TO_RGB(strColor, r, g, b);
     FX_ARGB rgb = ArgbEncode(100, r, g, b);
     for (int32_t i = 0; i < iSize; ++i) {
       CXFA_Edge edge = border.GetEdge(i);
       edge.SetColor(rgb);
     }
   } else {
     CXFA_Edge edge = border.GetEdge(0);
     FX_ARGB color = edge.GetColor();
     int32_t a, r, g, b;
     ArgbDecode(color, a, r, g, b);
     strColor.Format(L"%d,%d,%d", r, g, b);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(strColor).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(strColor).AsStringC());
   }
 }
 void CXFA_Node::Script_Som_BorderWidth(FXJSE_HVALUE hValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Border border = pWidgetData->GetBorder(TRUE);
   int32_t iSize = border.CountEdges();
   CFX_WideString wsThickness;
   if (bSetting) {
     CFX_ByteString bsValue;
     FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsThickness = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    wsThickness = CFX_WideString::FromUTF8(bsValue.AsStringC());
     for (int32_t i = 0; i < iSize; ++i) {
       CXFA_Edge edge = border.GetEdge(i);
-      CXFA_Measurement thickness(wsThickness.AsWideStringC());
+      CXFA_Measurement thickness(wsThickness.AsStringC());
       edge.SetMSThickness(thickness);
     }
   } else {
     CXFA_Edge edge = border.GetEdge(0);
     CXFA_Measurement thickness = edge.GetMSThickness();
     thickness.ToString(wsThickness);
-    FXJSE_Value_SetUTF8String(hValue,
-                              FX_UTF8Encode(wsThickness).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsThickness).AsStringC());
   }
 }
 void CXFA_Node::Script_Som_FillColor(FXJSE_HVALUE hValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Border border = pWidgetData->GetBorder(TRUE);
   CXFA_Fill borderfill = border.GetFill(TRUE);
   CXFA_Node* pNode = borderfill.GetNode();
   if (!pNode) {
     return;
   }
   CFX_WideString wsColor;
   if (bSetting) {
     CFX_ByteString bsValue;
     FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsColor = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    wsColor = CFX_WideString::FromUTF8(bsValue.AsStringC());
     int32_t r, g, b;
     XFA_STRING_TO_RGB(wsColor, r, g, b);
     FX_ARGB color = ArgbEncode(0xff, r, g, b);
     borderfill.SetColor(color);
   } else {
     FX_ARGB color = borderfill.GetColor();
     int32_t a, r, g, b;
     ArgbDecode(color, a, r, g, b);
     wsColor.Format(L"%d,%d,%d", r, g, b);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsColor).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsColor).AsStringC());
   }
 }
 void CXFA_Node::Script_Som_DataNode(FXJSE_HVALUE hValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CXFA_Node* pDataNode = GetBindData();
     if (pDataNode) {
       FXJSE_Value_Set(
           hValue,
@@ skipping 10 matching lines @@
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     if (FXJSE_Value_IsUTF8String(hValue)) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       FXSYS_assert(pWidgetData);
       XFA_ELEMENT uiType = pWidgetData->GetUIType();
       if (uiType == XFA_ELEMENT_Text) {
         CFX_ByteString newValue;
         FXJSE_Value_ToUTF8String(hValue, newValue);
         CFX_WideString wsNewValue =
-            CFX_WideString::FromUTF8(newValue.AsByteStringC());
+            CFX_WideString::FromUTF8(newValue.AsStringC());
         CFX_WideString wsFormatValue(wsNewValue);
         SetScriptContent(wsNewValue, wsFormatValue, TRUE, TRUE);
       } else if (uiType != XFA_ELEMENT_Image) {
       }
     }
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty()) {
       FXJSE_Value_SetNull(hValue);
     } else {
       FXJSE_Value_SetUTF8String(
-          hValue, FX_UTF8Encode(content, content.GetLength()).AsByteStringC());
+          hValue, FX_UTF8Encode(content, content.GetLength()).AsStringC());
     }
   }
 }
 void CXFA_Node::Script_Field_DefaultValue(FXJSE_HVALUE hValue,
                                           FX_BOOL bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     if (FXJSE_Value_IsNull(hValue)) {
       pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
       pWidgetData->m_bIsNull = TRUE;
     } else {
       pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
       pWidgetData->m_bIsNull = FALSE;
     }
     CFX_ByteString newValue;
     if (!(FXJSE_Value_IsNull(hValue) || FXJSE_Value_IsUndefined(hValue))) {
       FXJSE_Value_ToUTF8String(hValue, newValue);
     }
-    CFX_WideString wsNewText =
-        CFX_WideString::FromUTF8(newValue.AsByteStringC());
+    CFX_WideString wsNewText = CFX_WideString::FromUTF8(newValue.AsStringC());
     CXFA_Node* pUIChild = pWidgetData->GetUIChild();
     if (pUIChild->GetClassID() == XFA_ELEMENT_NumericEdit) {
       int32_t iLeadDigits = 0;
       int32_t iFracDigits = 0;
       pWidgetData->GetLeadDigits(iLeadDigits);
       pWidgetData->GetFracDigits(iFracDigits);
       wsNewText =
           pWidgetData->NumericLimit(wsNewText, iLeadDigits, iFracDigits);
     }
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     CFX_WideString wsFormatText(wsNewText);
     if (pContainerWidgetData) {
-      pContainerWidgetData->GetFormatDataValue(wsNewText.AsWideStringC(),
+      pContainerWidgetData->GetFormatDataValue(wsNewText.AsStringC(),
                                                wsFormatText);
     }
     SetScriptContent(wsNewText, wsFormatText, TRUE, TRUE);
   } else {
     CFX_WideString content = GetScriptContent(TRUE);
     if (content.IsEmpty()) {
       FXJSE_Value_SetNull(hValue);
     } else {
       CXFA_Node* pUIChild = pWidgetData->GetUIChild();
       XFA_ELEMENT eUI = pUIChild->GetClassID();
       CXFA_Value defVal = pWidgetData->GetFormValue();
       CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (pNode && pNode->GetClassID() == XFA_ELEMENT_Decimal) {
         if (eUI == XFA_ELEMENT_NumericEdit &&
             (pNode->GetInteger(XFA_ATTRIBUTE_FracDigits) == -1)) {
           FXJSE_Value_SetUTF8String(
-              hValue,
-              FX_UTF8Encode(content, content.GetLength()).AsByteStringC());
+              hValue, FX_UTF8Encode(content, content.GetLength()).AsStringC());
         } else {
-          CFX_Decimal decimal(content.AsWideStringC());
+          CFX_Decimal decimal(content.AsStringC());
           FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
         }
       } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Integer) {
         FXJSE_Value_SetInteger(hValue, FXSYS_wtoi(content));
       } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Boolean) {
         FXJSE_Value_SetBoolean(hValue, FXSYS_wtoi(content) == 0 ? FALSE : TRUE);
       } else if (pNode && pNode->GetClassID() == XFA_ELEMENT_Float) {
-        CFX_Decimal decimal(content.AsWideStringC());
+        CFX_Decimal decimal(content.AsStringC());
         FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
       } else {
         FXJSE_Value_SetUTF8String(
-            hValue,
-            FX_UTF8Encode(content, content.GetLength()).AsByteStringC());
+            hValue, FX_UTF8Encode(content, content.GetLength()).AsStringC());
       }
     }
   }
 }
 void CXFA_Node::Script_Field_EditValue(FXJSE_HVALUE hValue,
                                        FX_BOOL bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CFX_WideString wsValue;
   if (bSetting) {
     CFX_ByteString bsValue;
     FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsValue = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
     pWidgetData->SetValue(wsValue, XFA_VALUEPICTURE_Edit);
   } else {
     pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Edit);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsStringC());
   }
 }
 void CXFA_Node::Script_Som_FontColor(FXJSE_HVALUE hValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Font font = pWidgetData->GetFont(TRUE);
   CXFA_Node* pNode = font.GetNode();
   if (!pNode) {
     return;
   }
   CFX_WideString wsColor;
   if (bSetting) {
     CFX_ByteString bsValue;
     FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsColor = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    wsColor = CFX_WideString::FromUTF8(bsValue.AsStringC());
     int32_t r, g, b;
     XFA_STRING_TO_RGB(wsColor, r, g, b);
     FX_ARGB color = ArgbEncode(0xff, r, g, b);
     font.SetColor(color);
   } else {
     FX_ARGB color = font.GetColor();
     int32_t a, r, g, b;
     ArgbDecode(color, a, r, g, b);
     wsColor.Format(L"%d,%d,%d", r, g, b);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsColor).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsColor).AsStringC());
   }
 }
 void CXFA_Node::Script_Field_FormatMessage(FXJSE_HVALUE hValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(hValue, bSetting, XFA_SOM_FormatMessage);
 }
 void CXFA_Node::Script_Field_FormattedValue(FXJSE_HVALUE hValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CFX_WideString wsValue;
   if (bSetting) {
     CFX_ByteString bsValue;
     FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsValue = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
     pWidgetData->SetValue(wsValue, XFA_VALUEPICTURE_Display);
   } else {
     pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Display);
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsStringC());
   }
 }
 void CXFA_Node::Script_Som_Mandatory(FXJSE_HVALUE hValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CXFA_Validate validate = pWidgetData->GetValidate(TRUE);
   CFX_WideString wsValue;
   if (bSetting) {
     CFX_ByteString bsValue;
     FXJSE_Value_ToUTF8String(hValue, bsValue);
-    wsValue = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
     validate.SetNullTest(wsValue);
   } else {
     int32_t iValue = validate.GetNullTest();
     const XFA_ATTRIBUTEENUMINFO* pInfo =
         XFA_GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue);
     if (pInfo) {
       wsValue = pInfo->pName;
     }
-    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsStringC());
   }
 }
 void CXFA_Node::Script_Som_MandatoryMessage(FXJSE_HVALUE hValue,
                                             FX_BOOL bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(hValue, bSetting, XFA_SOM_MandatoryMessage);
 }
 void CXFA_Node::Script_Field_ParentSubform(FXJSE_HVALUE hValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
@@ skipping 26 matching lines @@
   if (!pWidgetData) {
     return;
   }
   pWidgetData->DeleteItem(-1, TRUE);
 }
 void CXFA_Node::Script_Field_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     int32_t iRet = execSingleEventByName(
-        CFX_WideString::FromUTF8(eventString.AsByteStringC()).AsWideStringC(),
+        CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_ELEMENT_Field);
     if (eventString == "validate") {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(),
                              ((iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE));
     }
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments) {
@@ skipping 40 matching lines @@
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
     return;
   }
   CFX_WideString wsValue;
   FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, TRUE);
   if (bHasItem) {
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
-        FX_UTF8Encode(wsValue, wsValue.GetLength()).AsByteStringC());
+        FX_UTF8Encode(wsValue, wsValue.GetLength()).AsStringC());
   } else {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   }
 }
 void CXFA_Node::Script_Field_BoundItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"boundItem");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CFX_ByteString bsValue = pArguments->GetUTF8String(0);
-  CFX_WideString wsValue = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+  CFX_WideString wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
   CFX_WideString wsBoundValue;
-  pWidgetData->GetItemValue(wsValue.AsWideStringC(), wsBoundValue);
+  pWidgetData->GetItemValue(wsValue.AsStringC(), wsBoundValue);
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
-    FXJSE_Value_SetUTF8String(hValue,
-                              FX_UTF8Encode(wsBoundValue).AsByteStringC());
+    FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsBoundValue).AsStringC());
   }
 }
 void CXFA_Node::Script_Field_GetItemState(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"getItemState");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
@@ skipping 36 matching lines @@
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
     return;
   }
   CFX_WideString wsValue;
   FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, FALSE);
   if (bHasItem) {
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
-        FX_UTF8Encode(wsValue, wsValue.GetLength()).AsByteStringC());
+        FX_UTF8Encode(wsValue, wsValue.GetLength()).AsStringC());
   } else {
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   }
 }
 void CXFA_Node::Script_Field_SetItemState(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 2) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"setItemState");
     return;
@@ skipping 18 matching lines @@
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CFX_WideString wsLabel;
   CFX_WideString wsValue;
   if (iLength >= 1) {
     CFX_ByteString bsLabel = pArguments->GetUTF8String(0);
-    wsLabel = CFX_WideString::FromUTF8(bsLabel.AsByteStringC());
+    wsLabel = CFX_WideString::FromUTF8(bsLabel.AsStringC());
   }
   if (iLength >= 2) {
     CFX_ByteString bsValue = pArguments->GetUTF8String(1);
-    wsValue = CFX_WideString::FromUTF8(bsValue.AsByteStringC());
+    wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
   }
   pWidgetData->InsertItem(wsLabel, wsValue, -1, TRUE);
 }
 void CXFA_Node::Script_Field_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (!pNotify) {
       FXJSE_Value_SetBoolean(pArguments->GetReturnValue(), FALSE);
     } else {
@@ skipping 19 matching lines @@
                                                     FX_BOOL bSetting,
                                                     XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     CFX_ByteString bsValue;
     FXJSE_Value_ToUTF8String(hValue, bsValue);
     pWidgetData->SetSelectedMemberByValue(
-        CFX_WideString::FromUTF8(bsValue.AsByteStringC()).AsWideStringC(), TRUE,
-        TRUE);
+        CFX_WideString::FromUTF8(bsValue.AsStringC()).AsStringC(), TRUE, TRUE);
   } else {
     CFX_WideString wsValue = GetScriptContent(TRUE);
     XFA_VERSION curVersion = GetDocument()->GetCurVersionMode();
     if (wsValue.IsEmpty() && curVersion >= XFA_VERSION_300) {
       FXJSE_Value_SetNull(hValue);
     } else {
-      FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsByteStringC());
+      FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsStringC());
     }
   }
 }
 void CXFA_Node::Script_ExclGroup_Transient(FXJSE_HVALUE hValue,
                                            FX_BOOL bSetting,
                                            XFA_ATTRIBUTE eAttribute) {}
 void CXFA_Node::Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     execSingleEventByName(
-        CFX_WideString::FromUTF8(eventString.AsByteStringC()).AsWideStringC(),
+        CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_ELEMENT_ExclGroup);
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 void CXFA_Node::Script_ExclGroup_SelectedMember(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc == 0) || (argc == 1)) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
       FXJSE_Value_SetNull(pArguments->GetReturnValue());
     } else {
       CXFA_Node* pReturnNode = NULL;
       if (argc == 0) {
         pReturnNode = pWidgetData->GetSelectedMember();
       } else {
         CFX_ByteString szName;
         szName = pArguments->GetUTF8String(0);
         pReturnNode = pWidgetData->SetSelectedMember(
-            CFX_WideString::FromUTF8(szName.AsByteStringC()).AsWideStringC());
+            CFX_WideString::FromUTF8(szName.AsStringC()).AsStringC());
       }
       if (pReturnNode) {
         FXJSE_Value_Set(
             pArguments->GetReturnValue(),
             m_pDocument->GetScriptContext()->GetJSValueFromMap(pReturnNode));
       } else {
         FXJSE_Value_SetNull(pArguments->GetReturnValue());
       }
     }
   } else {
@@ skipping 140 matching lines @@
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 void CXFA_Node::Script_Subform_Locale(FXJSE_HVALUE hValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString bsLocaleName;
     FXJSE_Value_ToUTF8String(hValue, bsLocaleName);
     SetCData(XFA_ATTRIBUTE_Locale,
-             CFX_WideString::FromUTF8(bsLocaleName.AsByteStringC()), TRUE,
-             TRUE);
+             CFX_WideString::FromUTF8(bsLocaleName.AsStringC()), TRUE, TRUE);
   } else {
     CFX_WideString wsLocaleName;
     GetLocaleName(wsLocaleName);
     FXJSE_Value_SetUTF8String(
         hValue,
-        FX_UTF8Encode(wsLocaleName, wsLocaleName.GetLength()).AsByteStringC());
+        FX_UTF8Encode(wsLocaleName, wsLocaleName.GetLength()).AsStringC());
   }
 }
 void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     execSingleEventByName(
-        CFX_WideString::FromUTF8(eventString.AsByteStringC()).AsWideStringC(),
+        CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_ELEMENT_Subform);
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 void CXFA_Node::Script_Subform_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetParser()->GetNotify();
     if (!pNotify) {
@@ skipping 85 matching lines @@
                             L"execInitialize");
   }
 }
 void CXFA_Node::Script_Template_CreateNode(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc > 0) && (argc < 4)) {
     CFX_WideString strTagName;
     CFX_WideString strName;
     CFX_WideString strNameSpace;
     CFX_ByteString bsTagName = pArguments->GetUTF8String(0);
-    strTagName = CFX_WideString::FromUTF8(bsTagName.AsByteStringC());
+    strTagName = CFX_WideString::FromUTF8(bsTagName.AsStringC());
     if (argc > 1) {
       CFX_ByteString bsName = pArguments->GetUTF8String(1);
-      strName = CFX_WideString::FromUTF8(bsName.AsByteStringC());
+      strName = CFX_WideString::FromUTF8(bsName.AsStringC());
       if (argc == 3) {
         CFX_ByteString bsNameSpace = pArguments->GetUTF8String(2);
-        strNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsByteStringC());
+        strNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC());
       }
     }
     const XFA_ELEMENTINFO* pElement =
-        XFA_GetElementByName(strTagName.AsWideStringC());
+        XFA_GetElementByName(strTagName.AsStringC());
     CXFA_Node* pNewNode = CreateSamePacketNode(pElement->eName);
     if (!pNewNode) {
       FXJSE_Value_SetNull(pArguments->GetReturnValue());
     } else {
       if (!strName.IsEmpty()) {
         if (XFA_GetAttributeOfElement(pElement->eName, XFA_ATTRIBUTE_Name,
                                       XFA_XDPPACKET_UNKNOWN)) {
-          pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsWideStringC(),
-                                 TRUE);
+          pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsStringC(), TRUE);
           if (pNewNode->GetPacketID() == XFA_XDPPACKET_Datasets) {
             pNewNode->CreateXMLMappingNode();
           }
           FXJSE_Value_Set(
               pArguments->GetReturnValue(),
               m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
         } else {
           ThrowScriptErrorMessage(XFA_IDS_NOT_HAVE_PROPERTY,
                                   (const FX_WCHAR*)strTagName, L"name");
         }
@@ skipping 736 matching lines @@
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"execValidate");
   }
 }
 void CXFA_Node::Script_Form_Checksum(FXJSE_HVALUE hValue,
                                      FX_BOOL bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString bsChecksum;
     FXJSE_Value_ToUTF8String(hValue, bsChecksum);
-    SetAttribute(
-        XFA_ATTRIBUTE_Checksum,
-        CFX_WideString::FromUTF8(bsChecksum.AsByteStringC()).AsWideStringC());
+    SetAttribute(XFA_ATTRIBUTE_Checksum,
+                 CFX_WideString::FromUTF8(bsChecksum.AsStringC()).AsStringC());
   } else {
     CFX_WideString wsChecksum;
     GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE);
     FXJSE_Value_SetUTF8String(
-        hValue,
-        FX_UTF8Encode(wsChecksum, wsChecksum.GetLength()).AsByteStringC());
+        hValue, FX_UTF8Encode(wsChecksum, wsChecksum.GetLength()).AsStringC());
   }
 }
 void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString bsAttributeName = pArguments->GetUTF8String(0);
     CFX_WideString wsAttributeValue;
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       static_cast<CFDE_XMLElement*>(pXMLNode)
-          ->GetString(CFX_WideString::FromUTF8(bsAttributeName.AsByteStringC()),
+          ->GetString(CFX_WideString::FromUTF8(bsAttributeName.AsStringC()),
                       wsAttributeValue);
     }
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
         FX_UTF8Encode(wsAttributeValue, wsAttributeValue.GetLength())
-            .AsByteStringC());
+            .AsStringC());
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"getAttribute");
   }
 }
 void CXFA_Node::Script_Packet_SetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 2) {
     CFX_ByteString bsValue = pArguments->GetUTF8String(0);
     CFX_ByteString bsName = pArguments->GetUTF8String(1);
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       static_cast<CFDE_XMLElement*>(pXMLNode)
-          ->SetString(CFX_WideString::FromUTF8(bsName.AsByteStringC()),
-                      CFX_WideString::FromUTF8(bsValue.AsByteStringC()));
+          ->SetString(CFX_WideString::FromUTF8(bsName.AsStringC()),
+                      CFX_WideString::FromUTF8(bsValue.AsStringC()));
     }
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"setAttribute");
   }
 }
 void CXFA_Node::Script_Packet_RemoveAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString bsName = pArguments->GetUTF8String(0);
-    CFX_WideString wsName = CFX_WideString::FromUTF8(bsName.AsByteStringC());
+    CFX_WideString wsName = CFX_WideString::FromUTF8(bsName.AsStringC());
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       if (pXMLElement->HasAttribute(wsName)) {
         pXMLElement->RemoveAttribute(wsName);
       }
     }
     FXJSE_Value_SetNull(pArguments->GetReturnValue());
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"removeAttribute");
   }
 }
 void CXFA_Node::Script_Packet_Content(FXJSE_HVALUE hValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString bsNewContent;
     FXJSE_Value_ToUTF8String(hValue, bsNewContent);
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->SetTextData(
-          CFX_WideString::FromUTF8(bsNewContent.AsByteStringC()));
+          CFX_WideString::FromUTF8(bsNewContent.AsStringC()));
     }
   } else {
     CFX_WideString wsTextData;
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->GetTextData(wsTextData);
     }
     FXJSE_Value_SetUTF8String(
-        hValue,
-        FX_UTF8Encode(wsTextData, wsTextData.GetLength()).AsByteStringC());
+        hValue, FX_UTF8Encode(wsTextData, wsTextData.GetLength()).AsStringC());
   }
 }
 void CXFA_Node::Script_Source_Next(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"next");
   }
 }
 void CXFA_Node::Script_Source_CancelBatch(CFXJSE_Arguments* pArguments) {
@@ skipping 131 matching lines @@
 void CXFA_Node::Script_Extras_Type(FXJSE_HVALUE hValue,
                                    FX_BOOL bSetting,
                                    XFA_ATTRIBUTE eAttribute) {}
 void CXFA_Node::Script_Script_Stateless(FXJSE_HVALUE hValue,
                                         FX_BOOL bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowScriptErrorMessage(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
-  FXJSE_Value_SetUTF8String(hValue,
-                            FX_UTF8Encode(FX_WSTRC(L"0")).AsByteStringC());
+  FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(FX_WSTRC(L"0")).AsStringC());
 }
 void CXFA_Node::Script_Encrypt_Format(FXJSE_HVALUE hValue,
                                       FX_BOOL bSetting,
                                       XFA_ATTRIBUTE eAttribute) {}
 enum XFA_KEYTYPE {
   XFA_KEYTYPE_Custom,
   XFA_KEYTYPE_Element,
 };
 void* XFA_GetMapKey_Custom(const CFX_WideStringC& wsKey) {
   uint32_t dwKey = FX_HashCode_String_GetW(wsKey.c_str(), wsKey.GetLength());
@@ skipping 199 matching lines @@
 FX_BOOL CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr,
                             const CFX_WideString& wsValue,
                             FX_BOOL bNotify,
                             FX_BOOL bScriptModify) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   OnChanging(eAttr, (void*)(const FX_WCHAR*)wsValue, bNotify);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pClone = new CFX_WideString(wsValue);
     SetUserData(pKey, pClone, &deleteWideStringCallBack);
   } else {
-    SetMapModuleString(pKey, wsValue.AsWideStringC());
+    SetMapModuleString(pKey, wsValue.AsStringC());
     if (eAttr == XFA_ATTRIBUTE_Name)
       UpdateNameHash();
   }
   OnChanged(eAttr, (void*)(const FX_WCHAR*)wsValue, bNotify, bScriptModify);
   if (IsNeedSavingXMLNode() && eAttr != XFA_ATTRIBUTE_QualifiedName &&
       eAttr != XFA_ATTRIBUTE_BindingNode) {
     if (eAttr == XFA_ATTRIBUTE_Name &&
         (m_eNodeClass == XFA_ELEMENT_DataValue ||
          m_eNodeClass == XFA_ELEMENT_DataGroup)) {
       return TRUE;
@@ skipping 336 matching lines @@
       }
       pBindNode = NULL;
       break;
     }
     case XFA_OBJECTTYPE_ContentNode: {
       CFX_WideString wsContentType;
       if (GetClassID() == XFA_ELEMENT_ExData) {
         GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
         if (wsContentType == FX_WSTRC(L"text/html")) {
           wsContentType = FX_WSTRC(L"");
-          SetAttribute(XFA_ATTRIBUTE_ContentType,
-                       wsContentType.AsWideStringC());
+          SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType.AsStringC());
         }
       }
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         pContentRawDataNode = CreateSamePacketNode(
             (wsContentType == FX_WSTRC(L"text/xml")) ? XFA_ELEMENT_Sharpxml
                                                      : XFA_ELEMENT_Sharptext);
         InsertChild(pContentRawDataNode);
       }
       return pContentRawDataNode->SetScriptContent(
@@ skipping 891 matching lines @@
       pDstModuleData->m_BufferMap.RemoveKey(pKey);
       pDstModuleData->m_BufferMap.SetAt(pKey,
                                         (XFA_MAPDATABLOCK*)pBufferBlockData);
     }
   }
   if (pDstModule->GetObjectType() == XFA_OBJECTTYPE_NodeV) {
     CFX_WideString wsValue = pDstModule->GetScriptContent(FALSE);
     CFX_WideString wsFormatValue(wsValue);
     CXFA_WidgetData* pWidgetData = pDstModule->GetContainerWidgetData();
     if (pWidgetData) {
-      pWidgetData->GetFormatDataValue(wsValue.AsWideStringC(), wsFormatValue);
+      pWidgetData->GetFormatDataValue(wsValue.AsStringC(), wsFormatValue);
     }
     pDstModule->SetScriptContent(wsValue, wsFormatValue, TRUE, TRUE);
   }
 }
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pSrcModule,
                                   CXFA_Node* pDstModule,
                                   void* pKey,
                                   FX_BOOL bRecursive) {
   if (!pSrcModule || !pDstModule || !pKey) {
     return;
@@ skipping 78 matching lines @@
     }
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"item");
   }
 }
 void CXFA_NodeList::Script_TreelistClass_NamedItem(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString szName = pArguments->GetUTF8String(0);
-    CXFA_Node* pNode = NamedItem(
-        CFX_WideString::FromUTF8(szName.AsByteStringC()).AsWideStringC());
+    CXFA_Node* pNode =
+        NamedItem(CFX_WideString::FromUTF8(szName.AsStringC()).AsStringC());
     if (!pNode) {
       return;
     }
     FXJSE_Value_Set(pArguments->GetReturnValue(),
                     m_pDocument->GetScriptContext()->GetJSValueFromMap(pNode));
   } else {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"namedItem");
   }
 }
 void CXFA_NodeList::Script_ListClass_Length(FXJSE_HVALUE hValue,
@@ skipping 76 matching lines @@
   return m_pAttachNode->InsertChild(pNewNode, pBeforeNode);
 }
 FX_BOOL CXFA_AttachNodeList::Remove(CXFA_Node* pNode) {
   return m_pAttachNode->RemoveChild(pNode);
 }
 CXFA_Node* CXFA_AttachNodeList::Item(int32_t iIndex) {
   return m_pAttachNode->GetChild(
       iIndex, XFA_ELEMENT_UNKNOWN,
       m_pAttachNode->GetClassID() == XFA_ELEMENT_Subform);
 }