Make down-conversion explicit from CFX_Widetring to CFX_WideStringC.

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 630 matching lines @@
     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,
-                                                resoveNodeRS, dwFlag);
+  int32_t iRet = pScriptContext->ResolveObjects(
+      refNode, wsExpression.AsWideStringC(), 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 38 matching lines @@
                                            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, resoveNodeRS, dwFlag);
+  pScriptContext->ResolveObjects(refNode, wsExpression.AsWideStringC(),
+                                 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) {
       CXFA_ObjArray objectArray;
@@ skipping 149 matching lines @@
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
                             L"getAttribute");
     return;
   }
   CFX_WideString wsExpression;
   CFX_ByteString bsExpression = pArguments->GetUTF8String(0);
   wsExpression =
       CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
   CFX_WideString wsValue;
-  GetAttribute(wsExpression, wsValue);
+  GetAttribute(wsExpression.AsWideStringC(), wsValue);
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
     FXJSE_Value_SetUTF8String(hValue, FX_UTF8Encode(wsValue).AsByteStringC());
   }
 }
 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, bsExpression.GetLength());
   }
   if (iLength >= 2) {
     iValue = pArguments->GetInt32(1);
   }
-  const XFA_ELEMENTINFO* pElementInfo = XFA_GetElementByName(wsExpression);
+  const XFA_ELEMENTINFO* pElementInfo =
+      XFA_GetElementByName(wsExpression.AsWideStringC());
   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, bsExpression.GetLength());
   }
   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);
+      XFA_GetAttributeByName(wsExpression.AsWideStringC());
   CFX_WideString wsValue;
   if (pAttributeInfo) {
     bHas = HasAttribute(pAttributeInfo->eName);
   }
   if (!bHas) {
-    const XFA_ELEMENTINFO* pElementInfo = XFA_GetElementByName(wsExpression);
+    const XFA_ELEMENTINFO* pElementInfo =
+        XFA_GetElementByName(wsExpression.AsWideStringC());
     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) {
@@ skipping 202 matching lines @@
                             L"setAttribute");
     return;
   }
   CFX_WideString wsAttribute;
   CFX_WideString wsAttributeValue;
   CFX_ByteString bsAttributeValue = pArguments->GetUTF8String(0);
   CFX_ByteString bsAttribute = pArguments->GetUTF8String(1);
   wsAttributeValue =
       CFX_WideString::FromUTF8(bsAttributeValue, bsAttributeValue.GetLength());
   wsAttribute = CFX_WideString::FromUTF8(bsAttribute, bsAttribute.GetLength());
-  SetAttribute(wsAttribute, wsAttributeValue, TRUE);
+  SetAttribute(wsAttribute.AsWideStringC(), wsAttributeValue.AsWideStringC(),
+               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) {
@@ skipping 304 matching lines @@
   }
 }
 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, szValue.GetLength());
-    SetAttribute(eAttribute, wsValue, TRUE);
+    SetAttribute(eAttribute, wsValue.AsWideStringC(), 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, resoveNodeRS, dwFlag);
+            pProtoRoot, wsSOM.AsWideStringC(), resoveNodeRS, dwFlag);
         if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) {
           pProtoNode = resoveNodeRS.nodes[0]->AsNode();
         }
       } else if (!wsID.IsEmpty()) {
-        pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID);
+        pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID.AsWideStringC());
       }
       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);
@@ skipping 167 matching lines @@
         }
         if (!wsPicture.IsEmpty()) {
           break;
         }
         pContainerWidgetData = NULL;
       }
     } else if (GetPacketID() == XFA_XDPPACKET_Form) {
       pContainerWidgetData = GetContainerWidgetData();
     }
     if (pContainerWidgetData) {
-      pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue);
+      pContainerWidgetData->GetFormatDataValue(wsNewValue.AsWideStringC(),
+                                               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);
+      CFX_Decimal decimal(content.AsWideStringC());
       FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
     } else {
       FXJSE_Value_SetUTF8String(
           hValue, FX_UTF8Encode(content, content.GetLength()).AsByteStringC());
     }
   }
 }
 void CXFA_Node::Script_Som_DefaultValue_Read(FXJSE_HVALUE hValue,
                                              FX_BOOL bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
@@ skipping 15 matching lines @@
   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, wsFormatValue);
+      pContainerWidgetData->GetFormatDataValue(wsNewValue.AsWideStringC(),
+                                               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:
   uint32_t m_uHash;
@@ skipping 122 matching lines @@
   }
   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, bsValue.GetLength());
     for (int32_t i = 0; i < iSize; ++i) {
       CXFA_Edge edge = border.GetEdge(i);
-      CXFA_Measurement thickness(wsThickness);
+      CXFA_Measurement thickness(wsThickness.AsWideStringC());
       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());
   }
 }
@@ skipping 96 matching lines @@
     if (pUIChild->GetClassID() == XFA_ELEMENT_NumericEdit) {
       int32_t iLeadDigits = 0;
       int32_t iFracDigits = 0;
       pWidgetData->GetLeadDigits(iLeadDigits);
       pWidgetData->GetFracDigits(iFracDigits);
       wsNewText = XFA_NumericLimit(wsNewText, iLeadDigits, iFracDigits);
     }
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     CFX_WideString wsFormatText(wsNewText);
     if (pContainerWidgetData) {
-      pContainerWidgetData->GetFormatDataValue(wsNewText, wsFormatText);
+      pContainerWidgetData->GetFormatDataValue(wsNewText.AsWideStringC(),
+                                               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());
         } else {
-          CFX_Decimal decimal(content);
+          CFX_Decimal decimal(content.AsWideStringC());
           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);
+        CFX_Decimal decimal(content.AsWideStringC());
         FXJSE_Value_SetFloat(hValue, (FX_FLOAT)(double)decimal);
       } else {
         FXJSE_Value_SetUTF8String(
             hValue,
             FX_UTF8Encode(content, content.GetLength()).AsByteStringC());
       }
     }
   }
 }
 void CXFA_Node::Script_Field_EditValue(FXJSE_HVALUE hValue,
@@ skipping 127 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, eventString.GetLength()),
+        CFX_WideString::FromUTF8(eventString, eventString.GetLength())
+            .AsWideStringC(),
         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 59 matching lines @@
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CFX_ByteString bsValue = pArguments->GetUTF8String(0);
   CFX_WideString wsValue =
       CFX_WideString::FromUTF8(bsValue, bsValue.GetLength());
   CFX_WideString wsBoundValue;
-  pWidgetData->GetItemValue(wsValue, wsBoundValue);
+  pWidgetData->GetItemValue(wsValue.AsWideStringC(), wsBoundValue);
   FXJSE_HVALUE hValue = pArguments->GetReturnValue();
   if (hValue) {
     FXJSE_Value_SetUTF8String(hValue,
                               FX_UTF8Encode(wsBoundValue).AsByteStringC());
   }
 }
 void CXFA_Node::Script_Field_GetItemState(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD,
@@ skipping 123 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, bsValue.GetLength()), TRUE, TRUE);
+        CFX_WideString::FromUTF8(bsValue, bsValue.GetLength()).AsWideStringC(),
+        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());
     }
   }
 }
 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, eventString.GetLength()),
+        CFX_WideString::FromUTF8(eventString, eventString.GetLength())
+            .AsWideStringC(),
         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, szName.GetLength()));
+            CFX_WideString::FromUTF8(szName, szName.GetLength())
+                .AsWideStringC());
       }
       if (pReturnNode) {
         FXJSE_Value_Set(
             pArguments->GetReturnValue(),
             m_pDocument->GetScriptContext()->GetJSValueFromMap(pReturnNode));
       } else {
         FXJSE_Value_SetNull(pArguments->GetReturnValue());
       }
     }
   } else {
@@ skipping 155 matching lines @@
     FXJSE_Value_SetUTF8String(
         hValue,
         FX_UTF8Encode(wsLocaleName, wsLocaleName.GetLength()).AsByteStringC());
   }
 }
 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, eventString.GetLength()),
+        CFX_WideString::FromUTF8(eventString, eventString.GetLength())
+            .AsWideStringC(),
         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 95 matching lines @@
     strTagName = CFX_WideString::FromUTF8(bsTagName, bsTagName.GetLength());
     if (argc > 1) {
       CFX_ByteString bsName = pArguments->GetUTF8String(1);
       strName = CFX_WideString::FromUTF8(bsName, bsName.GetLength());
       if (argc == 3) {
         CFX_ByteString bsNameSpace = pArguments->GetUTF8String(2);
         strNameSpace =
             CFX_WideString::FromUTF8(bsNameSpace, bsNameSpace.GetLength());
       }
     }
-    const XFA_ELEMENTINFO* pElement = XFA_GetElementByName(strTagName);
+    const XFA_ELEMENTINFO* pElement =
+        XFA_GetElementByName(strTagName.AsWideStringC());
     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, TRUE);
+          pNewNode->SetAttribute(XFA_ATTRIBUTE_Name, strName.AsWideStringC(),
+                                 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 737 matching lines @@
                             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, bsChecksum.GetLength()));
+                 CFX_WideString::FromUTF8(bsChecksum, bsChecksum.GetLength())
+                     .AsWideStringC());
   } else {
     CFX_WideString wsChecksum;
     GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE);
     FXJSE_Value_SetUTF8String(
         hValue,
         FX_UTF8Encode(wsChecksum, wsChecksum.GetLength()).AsByteStringC());
   }
 }
 void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
@@ skipping 439 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);
+    SetMapModuleString(pKey, wsValue.AsWideStringC());
     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);
+          SetAttribute(XFA_ATTRIBUTE_ContentType,
+                       wsContentType.AsWideStringC());
         }
       }
       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, wsFormatValue);
+      pWidgetData->GetFormatDataValue(wsValue.AsWideStringC(), 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, szName.GetLength()));
+    CXFA_Node* pNode = NamedItem(
+        CFX_WideString::FromUTF8(szName, szName.GetLength()).AsWideStringC());
     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);
 }