Rename GetCStr and GetPtr to match CFX_ByteString

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 38 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.GetPtr(), className.GetLength())
+        hValue, FX_UTF8Encode(className.raw_str(), className.GetLength())
                     .AsByteStringC());
   } 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);
@@ skipping 1024 matching lines @@
     IFX_Stream* pStream = IFX_Stream::CreateStream(
         (IFX_FileWrite*)pMemoryStream,
         FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
     if (!pStream) {
       FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
       pMemoryStream->Release();
       pMemoryStream = NULL;
       return;
     }
     pStream->SetCodePage(FX_CODEPAGE_UTF8);
-    pStream->WriteData(bsXMLHeader.GetPtr(), bsXMLHeader.GetLength());
+    pStream->WriteData(bsXMLHeader.raw_str(), bsXMLHeader.GetLength());
     XFA_DataExporter_RegenerateFormFile(this, pStream, NULL, TRUE);
     FXJSE_Value_SetUTF8String(
         pArguments->GetReturnValue(),
         CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
     pStream->Release();
     pStream = NULL;
     if (pMemoryStream) {
       pMemoryStream->Release();
       pMemoryStream = NULL;
     }
     return;
   }
   if (GetPacketID() == XFA_XDPPACKET_Datasets) {
     CFDE_XMLNode* pElement = GetXMLMappingNode();
     if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
       FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(), bsXMLHeader);
       return;
     }
     XFA_DataExporter_DealWithDataGroupNode(this);
     IFX_MemoryStream* pMemoryStream = FX_CreateMemoryStream(TRUE);
     IFX_Stream* pStream = IFX_Stream::CreateStream(
         (IFX_FileWrite*)pMemoryStream,
         FX_STREAMACCESS_Text | FX_STREAMACCESS_Write | FX_STREAMACCESS_Append);
     if (pStream) {
       pStream->SetCodePage(FX_CODEPAGE_UTF8);
-      pStream->WriteData(bsXMLHeader.GetPtr(), bsXMLHeader.GetLength());
+      pStream->WriteData(bsXMLHeader.raw_str(), bsXMLHeader.GetLength());
       pElement->SaveXMLNode(pStream);
       FXJSE_Value_SetUTF8String(pArguments->GetReturnValue(),
                                 CFX_ByteStringC(pMemoryStream->GetBuffer(),
                                                 pMemoryStream->GetSize()));
       pStream->Release();
       pStream = NULL;
     }
     if (pMemoryStream) {
       pMemoryStream->Release();
       pMemoryStream = NULL;
@@ skipping 645 matching lines @@
     {0xd95657a6, L"click", XFA_EVENT_Click, 4},
     {0xdbfbe02e, L"calculate", XFA_EVENT_Calculate, 1},
     {0xe25fa7b8, L"postOpen", XFA_EVENT_PostOpen, 7},
     {0xe28dce7e, L"enter", XFA_EVENT_Enter, 2},
     {0xfc82d695, L"postSave", XFA_EVENT_PostSave, 0},
     {0xfd54fbb7, L"postSign", XFA_EVENT_PostSign, 6},
 };
 const XFA_ExecEventParaInfo* GetEventParaInfoByName(
     const CFX_WideStringC& wsEventName) {
   int32_t iLength = wsEventName.GetLength();
-  uint32_t uHash = FX_HashCode_String_GetW(wsEventName.GetPtr(), iLength);
+  uint32_t uHash = FX_HashCode_String_GetW(wsEventName.raw_str(), iLength);
   const XFA_ExecEventParaInfo* eventParaInfo = NULL;
   int32_t iStart = 0,
           iEnd = (sizeof(gs_eventParaInfos) / sizeof(gs_eventParaInfos[0])) - 1;
   int32_t iMid = (iStart + iEnd) / 2;
   do {
     iMid = (iStart + iEnd) / 2;
     eventParaInfo = &gs_eventParaInfos[iMid];
     if (uHash == eventParaInfo->m_uHash) {
       return eventParaInfo;
     } else if (uHash < eventParaInfo->m_uHash) {
@@ skipping 1940 matching lines @@
                             FX_UTF8Encode(FX_WSTRC(L"0")).AsByteStringC());
 }
 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.GetPtr(), wsKey.GetLength());
+  uint32_t dwKey = FX_HashCode_String_GetW(wsKey.raw_str(), wsKey.GetLength());
   return (void*)(uintptr_t)((dwKey << 1) | XFA_KEYTYPE_Custom);
 }
 void* XFA_GetMapKey_Element(XFA_ELEMENT eElement, XFA_ATTRIBUTE eAttribute) {
   return (void*)(uintptr_t)((eElement << 16) | (eAttribute << 8) |
                             XFA_KEYTYPE_Element);
 }
 FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) {
   void* pKey = XFA_GetMapKey_Element(GetClassID(), eAttr);
   return HasMapModuleKey(pKey, bCanInherit);
 }
@@ skipping 18 matching lines @@
                            : (XFA_ATTRIBUTEENUM)(intptr_t)(pAttr->pDefValue),
                      bNotify);
     } break;
     case XFA_ATTRIBUTETYPE_Cdata:
       return SetCData(pAttr->eName, wsValue, bNotify);
     case XFA_ATTRIBUTETYPE_Boolean:
       return SetBoolean(pAttr->eName, wsValue != FX_WSTRC(L"0"), bNotify);
     case XFA_ATTRIBUTETYPE_Integer:
       return SetInteger(
           pAttr->eName,
-          FXSYS_round(FX_wcstof(wsValue.GetPtr(), wsValue.GetLength())),
+          FXSYS_round(FX_wcstof(wsValue.raw_str(), wsValue.GetLength())),
           bNotify);
     case XFA_ATTRIBUTETYPE_Measure:
       return SetMeasure(pAttr->eName, CXFA_Measurement(wsValue), bNotify);
     default:
       break;
   }
   return FALSE;
 }
 FX_BOOL CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr,
                                 CFX_WideString& wsValue,
@@ skipping 921 matching lines @@
   m_pDocument->AddPurgeNode(pNode);
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     if (pNode->IsAttributeInXML()) {
       FXSYS_assert(pNode->m_pXMLNode == m_pXMLNode &&
                    m_pXMLNode->GetType() == FDE_XMLNODE_Element);
       if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) {
         CFDE_XMLElement* pXMLElement =
             static_cast<CFDE_XMLElement*>(pNode->m_pXMLNode);
         CFX_WideStringC wsAttributeName =
             pNode->GetCData(XFA_ATTRIBUTE_QualifiedName);
-        pXMLElement->RemoveAttribute(wsAttributeName.GetPtr());
+        pXMLElement->RemoveAttribute(wsAttributeName.raw_str());
       }
       CFX_WideString wsName;
       pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
       CFDE_XMLElement* pNewXMLElement = new CFDE_XMLElement(wsName);
       CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pNewXMLElement->SetTextData(wsValue);
       }
       pNode->m_pXMLNode = pNewXMLElement;
       pNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       m_pXMLNode->RemoveChildNode(pNode->m_pXMLNode);
     }
     pNode->SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
   }
   return TRUE;
 }
 CXFA_Node* CXFA_Node::GetFirstChildByName(const CFX_WideStringC& wsName) const {
   return GetFirstChildByName(
-      wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
+      wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.raw_str(),
                                                      wsName.GetLength()));
 }
 CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return NULL;
@@ skipping 13 matching lines @@
     if (pNode->GetNameHash() == dwNameHash) {
       return pNode;
     }
   }
   return NULL;
 }
 CXFA_Node* CXFA_Node::GetNextSameNameSibling(
     const CFX_WideStringC& wsNodeName) const {
   return GetNextSameNameSibling(
       wsNodeName.IsEmpty() ? 0
-                           : FX_HashCode_String_GetW(wsNodeName.GetPtr(),
+                           : FX_HashCode_String_GetW(wsNodeName.raw_str(),
                                                      wsNodeName.GetLength()));
 }
 CXFA_Node* CXFA_Node::GetNextSameClassSibling(XFA_ELEMENT eElement) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_NextSibling); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetClassID() == eElement) {
       return pNode;
     }
   }
   return NULL;
@@ skipping 172 matching lines @@
     }
   }
   return iRet;
 }
 void CXFA_Node::UpdateNameHash() {
   const XFA_NOTSUREATTRIBUTE* pNotsure =
       XFA_GetNotsureAttribute(GetClassID(), XFA_ATTRIBUTE_Name);
   if (!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) {
     CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
     m_dwNameHash =
-        wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
+        wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.raw_str(),
                                                        wsName.GetLength());
   } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
     CFX_WideStringC wsName =
         XFA_GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
     m_dwNameHash =
-        wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.GetPtr(),
+        wsName.IsEmpty() ? 0 : FX_HashCode_String_GetW(wsName.raw_str(),
                                                        wsName.GetLength());
   }
 }
 CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideStringC wsTag = GetCData(XFA_ATTRIBUTE_Name);
     m_pXMLNode = new CFDE_XMLElement(wsTag);
     SetFlag(XFA_NODEFLAG_OwnXMLNode, TRUE, FALSE);
   }
   return m_pXMLNode;
@@ skipping 25 matching lines @@
     if (pModule && pModule->m_ValueMap.Lookup(pKey, pValue)) {
       return TRUE;
     }
     pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets
                 ? pNode->GetTemplateNode()
                 : NULL;
   }
   return FALSE;
 }
 void CXFA_Node::SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue) {
-  SetMapModuleBuffer(pKey, (void*)wsValue.GetPtr(),
+  SetMapModuleBuffer(pKey, (void*)wsValue.raw_str(),
                      wsValue.GetLength() * sizeof(FX_WCHAR));
 }
 FX_BOOL CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) {
   void* pValue;
   int32_t iBytes;
   if (!GetMapModuleBuffer(pKey, pValue, iBytes)) {
     return FALSE;
   }
   wsValue = CFX_WideStringC((const FX_WCHAR*)pValue, iBytes / sizeof(FX_WCHAR));
   return TRUE;
@@ skipping 208 matching lines @@
   }
   pSrcModule->MoveBufferMapData(pDstModule, pKey);
 }
 CXFA_NodeList::CXFA_NodeList(CXFA_Document* pDocument)
     : CXFA_Object(pDocument, XFA_OBJECTTYPE_NodeList) {
   m_pDocument->GetScriptContext()->CacheList(this);
 }
 CXFA_Node* CXFA_NodeList::NamedItem(const CFX_WideStringC& wsName) {
   int32_t iCount = GetLength();
   uint32_t dwHashCode =
-      FX_HashCode_String_GetW(wsName.GetPtr(), wsName.GetLength());
+      FX_HashCode_String_GetW(wsName.raw_str(), wsName.GetLength());
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_Node* ret = Item(i);
     if (dwHashCode == ret->GetNameHash()) {
       return ret;
     }
   }
   return NULL;
 }
 void CXFA_NodeList::Script_ListClass_Append(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
@@ skipping 146 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);
 }