Rename GetCStr and GetPtr to match CFX_ByteString

core/fxcrt/fx_basic_bstring.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 <stddef.h>
 
 #include <cctype>
 
@@ skipping 119 matching lines @@
   }
 }
 
 CFX_ByteString::CFX_ByteString(char ch) {
   m_pData.Reset(StringData::Create(1));
   m_pData->m_String[0] = ch;
 }
 
 CFX_ByteString::CFX_ByteString(const CFX_ByteStringC& stringSrc) {
   if (!stringSrc.IsEmpty()) {
-    m_pData.Reset(
-        StringData::Create(stringSrc.GetCStr(), stringSrc.GetLength()));
+    m_pData.Reset(StringData::Create(stringSrc.c_str(), stringSrc.GetLength()));
   }
 }
 
 CFX_ByteString::CFX_ByteString(const CFX_ByteStringC& str1,
                                const CFX_ByteStringC& str2) {
   int nNewLen = str1.GetLength() + str2.GetLength();
   if (nNewLen == 0)
     return;
 
   m_pData.Reset(StringData::Create(nNewLen));
-  m_pData->CopyContents(str1.GetCStr(), str1.GetLength());
-  m_pData->CopyContentsAt(str1.GetLength(), str2.GetCStr(), str2.GetLength());
+  m_pData->CopyContents(str1.c_str(), str1.GetLength());
+  m_pData->CopyContentsAt(str1.GetLength(), str2.c_str(), str2.GetLength());
 }
 
 CFX_ByteString::~CFX_ByteString() {}
 
 const CFX_ByteString& CFX_ByteString::operator=(const FX_CHAR* pStr) {
   if (!pStr || !pStr[0])
     clear();
   else
     AssignCopy(pStr, FXSYS_strlen(pStr));
 
   return *this;
 }
 
 const CFX_ByteString& CFX_ByteString::operator=(const CFX_ByteStringC& str) {
   if (str.IsEmpty())
     clear();
   else
-    AssignCopy(str.GetCStr(), str.GetLength());
+    AssignCopy(str.c_str(), str.GetLength());
 
   return *this;
 }
 
 const CFX_ByteString& CFX_ByteString::operator=(
     const CFX_ByteString& stringSrc) {
   if (m_pData != stringSrc.m_pData)
     m_pData = stringSrc.m_pData;
 
   return *this;
@@ skipping 27 matching lines @@
 
 const CFX_ByteString& CFX_ByteString::operator+=(const CFX_ByteString& str) {
   if (str.m_pData)
     Concat(str.m_pData->m_String, str.m_pData->m_nDataLength);
 
   return *this;
 }
 
 const CFX_ByteString& CFX_ByteString::operator+=(const CFX_ByteStringC& str) {
   if (!str.IsEmpty())
-    Concat(str.GetCStr(), str.GetLength());
+    Concat(str.c_str(), str.GetLength());
 
   return *this;
 }
 
 bool CFX_ByteString::operator==(const char* ptr) const {
   if (!m_pData)
     return !ptr || !ptr[0];
 
   if (!ptr)
     return m_pData->m_nDataLength == 0;
 
   return FXSYS_strlen(ptr) == m_pData->m_nDataLength &&
          FXSYS_memcmp(ptr, m_pData->m_String, m_pData->m_nDataLength) == 0;
 }
 
 bool CFX_ByteString::operator==(const CFX_ByteStringC& str) const {
   if (!m_pData)
     return str.IsEmpty();
 
   return m_pData->m_nDataLength == str.GetLength() &&
-         FXSYS_memcmp(m_pData->m_String, str.GetCStr(), str.GetLength()) == 0;
+         FXSYS_memcmp(m_pData->m_String, str.c_str(), str.GetLength()) == 0;
 }
 
 bool CFX_ByteString::operator==(const CFX_ByteString& other) const {
   if (IsEmpty())
     return other.IsEmpty();
 
   if (other.IsEmpty())
     return false;
 
   return other.m_pData->m_nDataLength == m_pData->m_nDataLength &&
          FXSYS_memcmp(other.m_pData->m_String, m_pData->m_String,
                       m_pData->m_nDataLength) == 0;
 }
 
 bool CFX_ByteString::EqualNoCase(const CFX_ByteStringC& str) const {
   if (!m_pData)
     return str.IsEmpty();
 
   FX_STRSIZE len = str.GetLength();
   if (m_pData->m_nDataLength != len)
     return false;
 
   const uint8_t* pThis = (const uint8_t*)m_pData->m_String;
-  const uint8_t* pThat = str.GetPtr();
+  const uint8_t* pThat = str.raw_str();
   for (FX_STRSIZE i = 0; i < len; i++) {
     if ((*pThis) != (*pThat)) {
       uint8_t bThis = *pThis;
       if (bThis >= 'A' && bThis <= 'Z')
         bThis += 'a' - 'A';
 
       uint8_t bThat = *pThat;
       if (bThat >= 'A' && bThat <= 'Z')
         bThat += 'a' - 'A';
 
@@ skipping 486 matching lines @@
                                 FX_STRSIZE nStart) const {
   if (!m_pData)
     return -1;
 
   FX_STRSIZE nLength = m_pData->m_nDataLength;
   if (nStart > nLength)
     return -1;
 
   const FX_CHAR* pStr =
       FX_strstr(m_pData->m_String + nStart, m_pData->m_nDataLength - nStart,
-                pSub.GetCStr(), pSub.GetLength());
+                pSub.c_str(), pSub.GetLength());
   return pStr ? (int)(pStr - m_pData->m_String) : -1;
 }
 
 void CFX_ByteString::MakeLower() {
   if (!m_pData)
     return;
 
   ReallocBeforeWrite(m_pData->m_nDataLength);
   FXSYS_strlwr(m_pData->m_String);
 }
@@ skipping 32 matching lines @@
   if (!m_pData || pOld.IsEmpty())
     return 0;
 
   FX_STRSIZE nSourceLen = pOld.GetLength();
   FX_STRSIZE nReplacementLen = pNew.GetLength();
   FX_STRSIZE nCount = 0;
   const FX_CHAR* pStart = m_pData->m_String;
   FX_CHAR* pEnd = m_pData->m_String + m_pData->m_nDataLength;
   while (1) {
     const FX_CHAR* pTarget = FX_strstr(pStart, (FX_STRSIZE)(pEnd - pStart),
-                                       pOld.GetCStr(), nSourceLen);
+                                       pOld.c_str(), nSourceLen);
     if (!pTarget)
       break;
 
     nCount++;
     pStart = pTarget + nSourceLen;
   }
   if (nCount == 0)
     return 0;
 
   FX_STRSIZE nNewLength =
       m_pData->m_nDataLength + (nReplacementLen - nSourceLen) * nCount;
 
   if (nNewLength == 0) {
     clear();
     return nCount;
   }
 
   CFX_RetainPtr<StringData> pNewData(StringData::Create(nNewLength));
   pStart = m_pData->m_String;
   FX_CHAR* pDest = pNewData->m_String;
   for (FX_STRSIZE i = 0; i < nCount; i++) {
     const FX_CHAR* pTarget = FX_strstr(pStart, (FX_STRSIZE)(pEnd - pStart),
-                                       pOld.GetCStr(), nSourceLen);
+                                       pOld.c_str(), nSourceLen);
     FXSYS_memcpy(pDest, pStart, pTarget - pStart);
     pDest += pTarget - pStart;
-    FXSYS_memcpy(pDest, pNew.GetCStr(), pNew.GetLength());
+    FXSYS_memcpy(pDest, pNew.c_str(), pNew.GetLength());
     pDest += pNew.GetLength();
     pStart = pTarget + nSourceLen;
   }
   FXSYS_memcpy(pDest, pStart, pEnd - pStart);
   m_pData.Swap(pNewData);
   return nCount;
 }
 
 void CFX_ByteString::SetAt(FX_STRSIZE nIndex, FX_CHAR ch) {
   if (!m_pData) {
@@ skipping 179 matching lines @@
     fraction %= scale;
     scale /= 10;
   }
   return buf_size;
 }
 CFX_ByteString CFX_ByteString::FormatFloat(FX_FLOAT d, int precision) {
   FX_CHAR buf[32];
   FX_STRSIZE len = FX_ftoa(d, buf);
   return CFX_ByteString(buf, len);
 }