Make CFX_StringData be scoped by CFX_Bytestring and add methods.

core/src/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>  // For offsetof().
 
 #include "../../include/fxcrt/fx_basic.h"
 #include "../../../third_party/base/numerics/safe_math.h"
@@ skipping 29 matching lines @@
     for (int ii = 0; ii < len; ii ++) {
         buf[ii] = buf1[ii + buf_pos + 1];
     }
     return len;
 }
 CFX_ByteString CFX_ByteString::FormatInteger(int i, FX_DWORD flags)
 {
     char buf[32];
     return CFX_ByteStringC(buf, _Buffer_itoa(buf, i, flags));
 }
-static CFX_StringData* FX_AllocString(int nLen)
+
+// static
+CFX_ByteString::StringData* CFX_ByteString::StringData::Create(int nLen)
 {
     // |nLen| is currently declared as in |int|. TODO(palmer): It should be
     // a |size_t|, or at least unsigned.
     if (nLen == 0 || nLen < 0) {
         return NULL;
     }
 
     // Fixed portion of header plus a NUL char not included in m_nAllocLength.
     // sizeof(FX_CHAR) is always 1, used for consistency with CFX_Widestring.
-    int overhead = offsetof(CFX_StringData, m_String) + sizeof(FX_CHAR);
+    int overhead = offsetof(StringData, m_String) + sizeof(FX_CHAR);
     pdfium::base::CheckedNumeric<int> nSize = nLen;
     nSize += overhead;
 
     // Now round to an 8-byte boundary. We'd expect that this is the minimum
     // granularity of any of the underlying allocators, so there may be cases
     // where we can save a re-alloc when adding a few characters to a string
     // by using this otherwise wasted space.
     nSize += 7;
     int totalSize = nSize.ValueOrDie() & ~7;
     int usableSize = totalSize - overhead;
     FXSYS_assert(usableSize >= nLen);
 
-    CFX_StringData* pData = (CFX_StringData*)FX_Alloc(FX_BYTE, totalSize);
+    void* pData = FX_Alloc(FX_BYTE, totalSize);
     if (!pData) {
         return NULL;
     }
-    pData->m_nAllocLength = usableSize;
-    pData->m_nDataLength = nLen;
-    pData->m_nRefs = 1;
-    pData->m_String[nLen] = 0;
-    return pData;
-}
-static void FX_ReleaseString(CFX_StringData* pData)
-{
-    if (pData == NULL) {
-        return;
-    }
-    pData->m_nRefs --;
-    if (pData->m_nRefs <= 0) {
-        FX_Free(pData);
-    }
+    return new (pData) StringData(nLen, usableSize);
 }
 CFX_ByteString::~CFX_ByteString()
 {
-    if (m_pData == NULL) {
-        return;
-    }
-    m_pData->m_nRefs --;
-    if (m_pData->m_nRefs < 1) {
-        FX_Free(m_pData);
+    if (m_pData) {
+        m_pData->Release();
     }
 }
 CFX_ByteString::CFX_ByteString(FX_LPCSTR lpsz, FX_STRSIZE nLen)
 {
     if (nLen < 0) {
         nLen = lpsz ? FXSYS_strlen(lpsz) : 0;
     }
     if (nLen) {
-        m_pData = FX_AllocString(nLen);
+        m_pData = StringData::Create(nLen);
         if (m_pData) {
             FXSYS_memcpy32(m_pData->m_String, lpsz, nLen);
         }
     } else {
         m_pData = NULL;
     }
 }
 CFX_ByteString::CFX_ByteString(FX_LPCBYTE lpsz, FX_STRSIZE nLen)
 {
     if (nLen > 0) {
-        m_pData = FX_AllocString(nLen);
+        m_pData = StringData::Create(nLen);
         if (m_pData) {
             FXSYS_memcpy32(m_pData->m_String, lpsz, nLen);
         }
     } else {
         m_pData = NULL;
     }
 }
 CFX_ByteString::CFX_ByteString(char ch)
 {
-    m_pData = FX_AllocString(1);
+    m_pData = StringData::Create(1);
     if (m_pData) {
         m_pData->m_String[0] = ch;
     }
 }
 CFX_ByteString::CFX_ByteString(const CFX_ByteString& stringSrc)
 {
     if (stringSrc.m_pData == NULL) {
         m_pData = NULL;
         return;
     }
     if (stringSrc.m_pData->m_nRefs >= 0) {
         m_pData = stringSrc.m_pData;
-        m_pData->m_nRefs ++;
+        m_pData->Retain();
     } else {
         m_pData = NULL;
         *this = stringSrc;
     }
 }
 CFX_ByteString::CFX_ByteString(FX_BSTR stringSrc)
 {
     if (stringSrc.IsEmpty()) {
         m_pData = NULL;
         return;
     } else {
         m_pData = NULL;
         *this = stringSrc;
     }
 }
 CFX_ByteString::CFX_ByteString(FX_BSTR str1, FX_BSTR str2)
 {
     m_pData = NULL;
     int nNewLen = str1.GetLength() + str2.GetLength();
     if (nNewLen == 0) {
         return;
     }
-    m_pData = FX_AllocString(nNewLen);
+    m_pData = StringData::Create(nNewLen);
     if (m_pData) {
         FXSYS_memcpy32(m_pData->m_String, str1.GetCStr(), str1.GetLength());
         FXSYS_memcpy32(m_pData->m_String + str1.GetLength(), str2.GetCStr(), str2.GetLength());
     }
 }
 const CFX_ByteString& CFX_ByteString::operator=(FX_LPCSTR lpsz)
 {
     if (lpsz == NULL || lpsz[0] == 0) {
         Empty();
     } else {
@@ skipping 17 matching lines @@
     }
     if (stringSrc.IsEmpty()) {
         Empty();
     } else if ((m_pData && m_pData->m_nRefs < 0) ||
                (stringSrc.m_pData && stringSrc.m_pData->m_nRefs < 0)) {
         AssignCopy(stringSrc.m_pData->m_nDataLength, stringSrc.m_pData->m_String);
     } else {
         Empty();
         m_pData = stringSrc.m_pData;
         if (m_pData) {
-            m_pData->m_nRefs ++;
+            m_pData->Retain();
         }
     }
     return *this;
 }
 const CFX_ByteString& CFX_ByteString::operator=(const CFX_BinaryBuf& buf)
 {
     Load(buf.GetBuffer(), buf.GetSize());
     return *this;
 }
 void CFX_ByteString::Load(FX_LPCBYTE buf, FX_STRSIZE len)
 {
     Empty();
     if (len) {
-        m_pData = FX_AllocString(len);
+        m_pData = StringData::Create(len);
         if (m_pData) {
             FXSYS_memcpy32(m_pData->m_String, buf, len);
         }
     } else {
         m_pData = NULL;
     }
 }
 const CFX_ByteString& CFX_ByteString::operator+=(FX_LPCSTR lpsz)
 {
     if (lpsz) {
@@ skipping 23 matching lines @@
     return *this;
 }
 bool CFX_ByteString::Equal(const char* ptr) const
 {
     if (!m_pData) {
         return !ptr || ptr[0] == '\0';
     }
     if (!ptr) {
         return m_pData->m_nDataLength == 0;
     }
-    return strlen(ptr) == m_pData->m_nDataLength &&
+    return FXSYS_strlen(ptr) == m_pData->m_nDataLength &&
         FXSYS_memcmp32(ptr, m_pData->m_String, m_pData->m_nDataLength) == 0;
 }
 bool CFX_ByteString::Equal(const CFX_ByteStringC& str) const
 {
     if (m_pData == NULL) {
         return str.IsEmpty();
     }
     return m_pData->m_nDataLength == str.GetLength() &&
         FXSYS_memcmp32(m_pData->m_String, str.GetCStr(), str.GetLength()) == 0;
 }
 bool CFX_ByteString::Equal(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_memcmp32(other.m_pData->m_String,
                        m_pData->m_String,
                        m_pData->m_nDataLength) == 0;
 }
 void CFX_ByteString::Empty()
 {
-    if (m_pData == NULL) {
-        return;
+    if (m_pData) {
+        m_pData->Release();
+        m_pData = NULL;
     }
-    if (m_pData->m_nRefs > 1) {
-        m_pData->m_nRefs --;
-    } else {
-        FX_Free(m_pData);
-    }
-    m_pData = NULL;
 }
 bool CFX_ByteString::EqualNoCase(FX_BSTR str) const
 {
     if (m_pData == NULL) {
         return str.IsEmpty();
     }
     FX_STRSIZE len = str.GetLength();
     if (m_pData->m_nDataLength != len) {
         return false;
     }
@@ skipping 23 matching lines @@
     AllocBeforeWrite(nSrcLen);
     FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen);
     m_pData->m_nDataLength = nSrcLen;
     m_pData->m_String[nSrcLen] = 0;
 }
 void CFX_ByteString::CopyBeforeWrite()
 {
     if (m_pData == NULL || m_pData->m_nRefs <= 1) {
         return;
     }
-    CFX_StringData* pData = m_pData;
-    m_pData->m_nRefs --;
+    StringData* pData = m_pData;
+    m_pData->Release();
     FX_STRSIZE nDataLength = pData->m_nDataLength;
-    m_pData = FX_AllocString(nDataLength);
+    m_pData = StringData::Create(nDataLength);
     if (m_pData != NULL) {
         FXSYS_memcpy32(m_pData->m_String, pData->m_String, nDataLength + 1);
     }
 }
 void CFX_ByteString::AllocBeforeWrite(FX_STRSIZE nLen)
 {
     if (m_pData && m_pData->m_nRefs <= 1 && m_pData->m_nAllocLength >= nLen) {
         return;
     }
     Empty();
-    m_pData = FX_AllocString(nLen);
+    m_pData = StringData::Create(nLen);
 }
 void CFX_ByteString::ReleaseBuffer(FX_STRSIZE nNewLength)
 {
     if (m_pData == NULL) {
         return;
     }
     CopyBeforeWrite();
     if (nNewLength == -1) {
         nNewLength = FXSYS_strlen((FX_LPCSTR)m_pData->m_String);
     }
@@ skipping 12 matching lines @@
 }
 FX_LPSTR CFX_ByteString::GetBuffer(FX_STRSIZE nMinBufLength)
 {
     if (m_pData == NULL && nMinBufLength == 0) {
         return NULL;
     }
     if (m_pData && m_pData->m_nRefs <= 1 && m_pData->m_nAllocLength >= nMinBufLength) {
         return m_pData->m_String;
     }
     if (m_pData == NULL) {
-        m_pData = FX_AllocString(nMinBufLength);
+        m_pData = StringData::Create(nMinBufLength);
         if (!m_pData) {
             return NULL;
         }
         m_pData->m_nDataLength = 0;
         m_pData->m_String[0] = 0;
         return m_pData->m_String;
     }
-    CFX_StringData* pOldData = m_pData;
+    StringData* pOldData = m_pData;
     FX_STRSIZE nOldLen = pOldData->m_nDataLength;
     if (nMinBufLength < nOldLen) {
         nMinBufLength = nOldLen;
     }
-    m_pData = FX_AllocString(nMinBufLength);
+    m_pData = StringData::Create(nMinBufLength);
     if (!m_pData) {
         return NULL;
     }
     FXSYS_memcpy32(m_pData->m_String, pOldData->m_String, (nOldLen + 1));
     m_pData->m_nDataLength = nOldLen;
-    pOldData->m_nRefs --;
-    if (pOldData->m_nRefs <= 0) {
-        FX_Free(pOldData);
-    }
+    pOldData->Release();
     return m_pData->m_String;
 }
 FX_STRSIZE CFX_ByteString::Delete(FX_STRSIZE nIndex, FX_STRSIZE nCount)
 {
     if (m_pData == NULL) {
         return 0;
     }
     if (nIndex < 0) {
         nIndex = 0;
     }
@@ skipping 11 matching lines @@
         m_pData->m_nDataLength = nOldLength - nCount;
     }
     return m_pData->m_nDataLength;
 }
 void CFX_ByteString::ConcatInPlace(FX_STRSIZE nSrcLen, FX_LPCSTR lpszSrcData)
 {
     if (nSrcLen == 0 || lpszSrcData == NULL) {
         return;
     }
     if (m_pData == NULL) {
-        m_pData = FX_AllocString(nSrcLen);
+        m_pData = StringData::Create(nSrcLen);
         if (!m_pData) {
             return;
         }
         FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen);
         return;
     }
     if (m_pData->m_nRefs > 1 || m_pData->m_nDataLength + nSrcLen > m_pData->m_nAllocLength) {
-        CFX_StringData* pOldData = m_pData;
+        StringData* pOldData = m_pData;
         ConcatCopy(m_pData->m_nDataLength, m_pData->m_String, nSrcLen, lpszSrcData);
-        FX_ReleaseString(pOldData);
+        pOldData->Release();
     } else {
         FXSYS_memcpy32(m_pData->m_String + m_pData->m_nDataLength, lpszSrcData, nSrcLen);
         m_pData->m_nDataLength += nSrcLen;
         m_pData->m_String[m_pData->m_nDataLength] = 0;
     }
 }
 void CFX_ByteString::ConcatCopy(FX_STRSIZE nSrc1Len, FX_LPCSTR lpszSrc1Data,
                                 FX_STRSIZE nSrc2Len, FX_LPCSTR lpszSrc2Data)
 {
     int nNewLen = nSrc1Len + nSrc2Len;
     if (nNewLen == 0) {
         return;
     }
-    m_pData = FX_AllocString(nNewLen);
+    m_pData = StringData::Create(nNewLen);
     if (m_pData) {
         FXSYS_memcpy32(m_pData->m_String, lpszSrc1Data, nSrc1Len);
         FXSYS_memcpy32(m_pData->m_String + nSrc1Len, lpszSrc2Data, nSrc2Len);
     }
 }
 CFX_ByteString CFX_ByteString::Mid(FX_STRSIZE nFirst) const
 {
     if (m_pData == NULL) {
         return CFX_ByteString();
     }
@@ skipping 21 matching lines @@
     return dest;
 }
 void CFX_ByteString::AllocCopy(CFX_ByteString& dest, FX_STRSIZE nCopyLen, FX_STRSIZE nCopyIndex) const
 {
     // |FX_STRSIZE| is currently typedef'd as in |int|. TODO(palmer): It
     // should be a |size_t|, or at least unsigned.
     if (nCopyLen == 0 || nCopyLen < 0) {
         return;
     }
     ASSERT(dest.m_pData == NULL);
-    dest.m_pData = FX_AllocString(nCopyLen);
+    dest.m_pData = StringData::Create(nCopyLen);
     if (dest.m_pData) {
         FXSYS_memcpy32(dest.m_pData->m_String, m_pData->m_String + nCopyIndex, nCopyLen);
     }
 }
 #define FORCE_ANSI      0x10000
 #define FORCE_UNICODE   0x20000
 #define FORCE_INT64     0x40000
 void CFX_ByteString::FormatV(FX_LPCSTR lpszFormat, va_list argList)
 {
     va_list argListSave;
@@ skipping 220 matching lines @@
     CopyBeforeWrite();
     if (nIndex < 0) {
         nIndex = 0;
     }
     FX_STRSIZE nNewLength = m_pData ? m_pData->m_nDataLength : 0;
     if (nIndex > nNewLength) {
         nIndex = nNewLength;
     }
     nNewLength++;
     if (m_pData == NULL || m_pData->m_nAllocLength < nNewLength) {
-        CFX_StringData* pOldData = m_pData;
+        StringData* pOldData = m_pData;
         FX_LPCSTR pstr = m_pData->m_String;
-        m_pData = FX_AllocString(nNewLength);
+        m_pData = StringData::Create(nNewLength);
         if (!m_pData) {
             return 0;
         }
         if(pOldData != NULL) {
             FXSYS_memmove32(m_pData->m_String, pstr, (pOldData->m_nDataLength + 1));
-            FX_ReleaseString(pOldData);
+            pOldData->Release();
         } else {
             m_pData->m_String[0] = 0;
         }
     }
     FXSYS_memmove32(m_pData->m_String + nIndex + 1,
                     m_pData->m_String + nIndex, (nNewLength - nIndex));
     m_pData->m_String[nIndex] = ch;
     m_pData->m_nDataLength = nNewLength;
     return nNewLength;
 }
@@ skipping 155 matching lines @@
         pStart = pTarget + nSourceLen;
     }
     if (nCount == 0) {
         return 0;
     }
     FX_STRSIZE nNewLength =  m_pData->m_nDataLength + (nReplacementLen - nSourceLen) * nCount;
     if (nNewLength == 0) {
         Empty();
         return nCount;
     }
-    CFX_StringData* pNewData = FX_AllocString(nNewLength);
+    StringData* pNewData = StringData::Create(nNewLength);
     if (!pNewData) {
         return 0;
     }
     pStart = m_pData->m_String;
     FX_LPSTR pDest = pNewData->m_String;
     for (FX_STRSIZE i = 0; i < nCount; i ++) {
         FX_LPCSTR pTarget = FX_strstr(pStart, (FX_STRSIZE)(pEnd - pStart), lpszOld.GetCStr(), nSourceLen);
         FXSYS_memcpy32(pDest, pStart, pTarget - pStart);
         pDest += pTarget - pStart;
         FXSYS_memcpy32(pDest, lpszNew.GetCStr(), lpszNew.GetLength());
         pDest += lpszNew.GetLength();
         pStart = pTarget + nSourceLen;
     }
     FXSYS_memcpy32(pDest, pStart, pEnd - pStart);
-    FX_ReleaseString(m_pData);
+    m_pData->Release();
     m_pData = pNewData;
     return nCount;
 }
 void CFX_ByteString::SetAt(FX_STRSIZE nIndex, FX_CHAR ch)
 {
     if (m_pData == NULL) {
         return;
     }
     FXSYS_assert(nIndex >= 0);
     FXSYS_assert(nIndex < m_pData->m_nDataLength);
@@ skipping 192 matching lines @@
         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);
 }