Make down-conversion explicit from CFX_Widetring to CFX_WideStringC.

xfa/fxfa/parser/xfa_objectacc_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 "core/fxcrt/include/fx_ext.h"
 #include "xfa/fxbarcode/include/BC_Library.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/fm2js/xfa_fm2jsapi.h"
@@ skipping 459 matching lines @@
 FX_BOOL CXFA_Image::GetContent(CFX_WideString& wsText) {
   return m_pNode->TryContent(wsText);
 }
 FX_BOOL CXFA_Image::SetContentType(const CFX_WideString& wsContentType) {
   return m_pNode->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
 }
 FX_BOOL CXFA_Image::SetHref(const CFX_WideString& wsHref) {
   if (m_bDefValue) {
     return m_pNode->SetCData(XFA_ATTRIBUTE_Href, wsHref);
   }
-  return m_pNode->SetAttribute(XFA_ATTRIBUTE_Href, wsHref);
+  return m_pNode->SetAttribute(XFA_ATTRIBUTE_Href, wsHref.AsWideStringC());
 }
 FX_BOOL CXFA_Image::SetTransferEncoding(int32_t iTransferEncoding) {
   if (m_bDefValue) {
     return m_pNode->SetEnum(XFA_ATTRIBUTE_TransferEncoding,
                             (XFA_ATTRIBUTEENUM)iTransferEncoding);
   }
   return TRUE;
 }
 CXFA_Calculate::CXFA_Calculate(CXFA_Node* pNode) : CXFA_Data(pNode) {}
 int32_t CXFA_Calculate::GetOverride() {
@@ skipping 12 matching lines @@
     }
   }
 }
 CXFA_Validate::CXFA_Validate(CXFA_Node* pNode) : CXFA_Data(pNode) {}
 int32_t CXFA_Validate::GetFormatTest() {
   return m_pNode->GetEnum(XFA_ATTRIBUTE_FormatTest);
 }
 FX_BOOL CXFA_Validate::SetTestValue(int32_t iType,
                                     CFX_WideString& wsValue,
                                     XFA_ATTRIBUTEENUM eName) {
-  const XFA_ATTRIBUTEENUMINFO* pInfo = XFA_GetAttributeEnumByName(wsValue);
+  const XFA_ATTRIBUTEENUMINFO* pInfo =
+      XFA_GetAttributeEnumByName(wsValue.AsWideStringC());
   if (pInfo) {
     eName = pInfo->eName;
   }
   m_pNode->SetEnum((XFA_ATTRIBUTE)iType, eName, FALSE);
   return TRUE;
 }
 FX_BOOL CXFA_Validate::SetNullTest(CFX_WideString wsValue) {
   return SetTestValue(XFA_ATTRIBUTE_NullTest, wsValue,
                       XFA_ATTRIBUTEENUM_Disabled);
 }
@@ skipping 1059 matching lines @@
           break;
         }
       }
       SetSelectdItems(iSelArray, bNotify, bScriptModify, bSyncData);
     }
   } else {
     if (bSelected) {
       if (iSel < 0) {
         CFX_WideString wsSaveText = wsSaveTextArray[nIndex];
         CFX_WideString wsFormatText(wsSaveText);
-        GetFormatDataValue(wsSaveText, wsFormatText);
+        GetFormatDataValue(wsSaveText.AsWideStringC(), wsFormatText);
         m_pNode->SetContent(wsSaveText, wsFormatText, bNotify, bScriptModify,
                             bSyncData);
       }
     } else if (iSel >= 0) {
       m_pNode->SetContent(CFX_WideString(), CFX_WideString(), bNotify,
                           bScriptModify, bSyncData);
     }
   }
 }
 void CXFA_WidgetData::SetSelectdItems(CFX_Int32Array& iSelArray,
                                       FX_BOOL bNotify,
                                       FX_BOOL bScriptModify,
                                       FX_BOOL bSyncData) {
   CFX_WideString wsValue;
   int32_t iSize = iSelArray.GetSize();
   if (iSize >= 1) {
     CFX_WideStringArray wsSaveTextArray;
     GetChoiceListItems(wsSaveTextArray, TRUE);
     CFX_WideString wsItemValue;
     for (int32_t i = 0; i < iSize; i++) {
       wsItemValue = (iSize == 1)
                         ? wsSaveTextArray[iSelArray[i]]
                         : wsSaveTextArray[iSelArray[i]] + FX_WSTRC(L"\n");
       wsValue += wsItemValue;
     }
   }
   CFX_WideString wsFormat(wsValue);
   if (GetChoiceListOpen() != XFA_ATTRIBUTEENUM_MultiSelect) {
-    GetFormatDataValue(wsValue, wsFormat);
+    GetFormatDataValue(wsValue.AsWideStringC(), wsFormat);
   }
   m_pNode->SetContent(wsValue, wsFormat, bNotify, bScriptModify, bSyncData);
 }
 void CXFA_WidgetData::ClearAllSelections() {
   CXFA_Node* pBind = m_pNode->GetBindData();
   if (pBind && GetChoiceListOpen() == XFA_ATTRIBUTEENUM_MultiSelect) {
     while (CXFA_Node* pChildNode =
                pBind->GetNodeItem(XFA_NODEITEM_FirstChild)) {
       pBind->RemoveChild(pChildNode);
     }
@@ skipping 16 matching lines @@
        pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pItemNode->GetClassID() != XFA_ELEMENT_Items) {
       continue;
     }
     listitems.Add(pItemNode);
     iCount++;
   }
   if (iCount < 1) {
     CXFA_Node* pItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
     m_pNode->InsertChild(-1, pItems);
-    InsertListTextItem(pItems, wsLabel, nIndex);
+    InsertListTextItem(pItems, wsLabel.AsWideStringC(), nIndex);
     CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
     m_pNode->InsertChild(-1, pSaveItems);
     pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
-    InsertListTextItem(pSaveItems, wsNewValue, nIndex);
+    InsertListTextItem(pSaveItems, wsNewValue.AsWideStringC(), nIndex);
   } else if (iCount > 1) {
     for (int32_t i = 0; i < 2; i++) {
       CXFA_Node* pNode = listitems[i];
       FX_BOOL bHasSave = pNode->GetBoolean(XFA_ATTRIBUTE_Save);
       if (bHasSave) {
-        InsertListTextItem(pNode, wsNewValue, nIndex);
+        InsertListTextItem(pNode, wsNewValue.AsWideStringC(), nIndex);
       } else {
-        InsertListTextItem(pNode, wsLabel, nIndex);
+        InsertListTextItem(pNode, wsLabel.AsWideStringC(), nIndex);
       }
     }
   } else {
     CXFA_Node* pNode = listitems[0];
     pNode->SetBoolean(XFA_ATTRIBUTE_Save, FALSE);
     pNode->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Visible);
     CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_ELEMENT_Items);
     m_pNode->InsertChild(-1, pSaveItems);
     pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
     pSaveItems->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Hidden);
     listitems.RemoveAll();
     CXFA_Node* pListNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
     int32_t i = 0;
     while (pListNode) {
       CFX_WideString wsOldValue;
       pListNode->TryContent(wsOldValue);
-      InsertListTextItem(pSaveItems, wsOldValue, i);
+      InsertListTextItem(pSaveItems, wsOldValue.AsWideStringC(), i);
       i++;
       pListNode = pListNode->GetNodeItem(XFA_NODEITEM_NextSibling);
     }
-    InsertListTextItem(pNode, wsLabel, nIndex);
-    InsertListTextItem(pSaveItems, wsNewValue, nIndex);
+    InsertListTextItem(pNode, wsLabel.AsWideStringC(), nIndex);
+    InsertListTextItem(pSaveItems, wsNewValue.AsWideStringC(), nIndex);
   }
   if (!bNotify) {
     return;
   }
   m_pNode->GetDocument()->GetNotify()->OnWidgetDataEvent(
       this, XFA_WIDGETEVENT_ListItemAdded, (void*)(const FX_WCHAR*)wsLabel,
       (void*)(const FX_WCHAR*)wsValue, (void*)(uintptr_t)nIndex);
 }
 void CXFA_WidgetData::GetItemLabel(const CFX_WideStringC& wsValue,
                                    CFX_WideString& wsLabel) {
@@ skipping 390 matching lines @@
     if (XFA_IsDigit(wc)) {
       if (iLead >= 0) {
         iLead_++;
         if (iLead_ > iLead) {
           return L"0";
         }
       } else if (iTread_ >= 0) {
         iTread_++;
         if (iTread_ > iTread) {
           if (iTread != -1) {
-            CFX_Decimal wsDeci = CFX_Decimal(wsValue);
+            CFX_Decimal wsDeci = CFX_Decimal(wsValue.AsWideStringC());
             wsDeci.SetScale(iTread);
             wsRet = wsDeci;
           }
           return wsRet;
         }
       }
     } else if (wc == L'.') {
       iTread_ = 0;
       iLead = -1;
     }
@@ skipping 154 matching lines @@
   if (!m_pNode) {
     return pLocale;
   }
   FX_BOOL bLocale = FALSE;
   CFX_WideString wsLocaleName;
   bLocale = m_pNode->GetLocaleName(wsLocaleName);
   if (bLocale) {
     if (wsLocaleName == FX_WSTRC(L"ambient")) {
       pLocale = m_pNode->GetDocument()->GetLocalMgr()->GetDefLocale();
     } else {
-      pLocale =
-          m_pNode->GetDocument()->GetLocalMgr()->GetLocaleByName(wsLocaleName);
+      pLocale = m_pNode->GetDocument()->GetLocalMgr()->GetLocaleByName(
+          wsLocaleName.AsWideStringC());
     }
   }
   return pLocale;
 }
 static FX_BOOL XFA_SplitDateTime(const CFX_WideString& wsDateTime,
                                  CFX_WideString& wsDate,
                                  CFX_WideString& wsTime) {
   wsDate = L"";
   wsTime = L"";
   if (wsDateTime.IsEmpty()) {
@@ skipping 34 matching lines @@
     }
   }
   return TRUE;
 }
 
 FX_BOOL CXFA_WidgetData::GetValue(CFX_WideString& wsValue,
                                   XFA_VALUEPICTURE eValueType) {
   wsValue = m_pNode->GetContent();
 
   if (eValueType == XFA_VALUEPICTURE_Display)
-    GetItemLabel(wsValue, wsValue);
+    GetItemLabel(wsValue.AsWideStringC(), wsValue);
 
   CFX_WideString wsPicture;
   GetPictureContent(wsPicture, eValueType);
   CXFA_Node* pNode = GetUIChild();
   if (!pNode)
     return TRUE;
 
   XFA_ELEMENT uiType = GetUIChild()->GetClassID();
   switch (uiType) {
     case XFA_ELEMENT_ChoiceList: {
@@ skipping 222 matching lines @@
   }
 }
 void CXFA_WidgetData::SyncValue(const CFX_WideString& wsValue,
                                 FX_BOOL bNotify) {
   if (!m_pNode) {
     return;
   }
   CFX_WideString wsFormatValue(wsValue);
   CXFA_WidgetData* pContainerWidgetData = m_pNode->GetContainerWidgetData();
   if (pContainerWidgetData) {
-    pContainerWidgetData->GetFormatDataValue(wsValue, wsFormatValue);
+    pContainerWidgetData->GetFormatDataValue(wsValue.AsWideStringC(),
+                                             wsFormatValue);
   }
   m_pNode->SetContent(wsValue, wsFormatValue, bNotify);
 }
 void CXFA_WidgetData::InsertListTextItem(CXFA_Node* pItems,
                                          const CFX_WideStringC& wsText,
                                          int32_t nIndex) {
   CXFA_Node* pText = pItems->CreateSamePacketNode(XFA_ELEMENT_Text);
   pItems->InsertChild(nIndex, pText);
   pText->SetContent(wsText, wsText, FALSE, FALSE, FALSE);
 }
@@ skipping 59 matching lines @@
     XFA_ATTRIBUTE attributeValue = XFA_ATTRIBUTE_Type,
     XFA_ATTRIBUTEENUM eDefaultValue = XFA_ATTRIBUTEENUM_Optional) {
   XFA_ATTRIBUTEENUM eType = eDefaultValue;
   if (pNode) {
     if (!pNode->TryEnum(attributeValue, eType, TRUE)) {
       eType = eDefaultValue;
     }
   }
   return eType;
 }