Make CFX_StringData be scoped by CFX_Bytestring and add methods.

core/include/fxcrt/fx_string.h

 // 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
 
 #ifndef _FX_STRING_H_
 #define _FX_STRING_H_
 
 #include <stdint.h>  // For intptr_t.
@@ skipping 153 matching lines @@
 inline bool operator== (const char* lhs, const CFX_ByteStringC& rhs) {
     return rhs == lhs;
 }
 inline bool operator!= (const char* lhs, const CFX_ByteStringC& rhs) {
     return rhs != lhs;
 }
 typedef const CFX_ByteStringC& FX_BSTR;
 #define FX_BSTRC(str) CFX_ByteStringC(str, sizeof str-1)
 #define FXBSTR_ID(c1, c2, c3, c4) ((c1 << 24) | (c2 << 16) | (c3 << 8) | (c4))
 
-// To ensure ref counts do not overflow, consider the worst possible case:
-// the entire address space contains nothing but pointers to this object.
-// Since the count increments with each new pointer, the largest value is
-// the number of pointers that can fit into the address space. The size of
-// the address space itself is a good upper bound on it; we need not go
-// larger.
-struct CFX_StringData {
-    intptr_t    m_nRefs;  // Would prefer ssize_t, but no windows support.
-    FX_STRSIZE  m_nDataLength;
-    FX_STRSIZE  m_nAllocLength;
-    FX_CHAR             m_String[1];
-};
-
 // A mutable string with shared buffers using copy-on-write semantics that
 // avoids the cost of std::string's iterator stability guarantees.
 class CFX_ByteString
 {
 public:
     typedef FX_CHAR value_type;
 
     CFX_ByteString()
     {
         m_pData = NULL;
@@ skipping 159 matching lines @@
 
     void                                        ConvertFrom(const CFX_WideString& str, CFX_CharMap* pCharMap = NULL);
 
     FX_DWORD                            GetID(FX_STRSIZE start_pos = 0) const;
 
 #define FXFORMAT_SIGNED                 1
 #define FXFORMAT_HEX                    2
 #define FXFORMAT_CAPITAL                4
 
     static CFX_ByteString       FormatInteger(int i, FX_DWORD flags = 0);
+    static CFX_ByteString       FormatFloat(FX_FLOAT f, int precision = 0);
 
-    static CFX_ByteString       FormatFloat(FX_FLOAT f, int precision = 0);
 protected:
+    // To ensure ref counts do not overflow, consider the worst possible case:
+    // the entire address space contains nothing but pointers to this object.
+    // Since the count increments with each new pointer, the largest value is
+    // the number of pointers that can fit into the address space. The size of
+    // the address space itself is a good upper bound on it; we need not go
+    // larger.
+    struct StringData {
+        static StringData* Create(int nLen);
+        void Retain() { ++m_nRefs; }

[Lei Zhang, 2015/05/14 19:28:39]

Once a struct starts having methods, it should probably become a class.

[Tom Sepez, 2015/05/14 19:54:43]

Done.

+        void Release() { if (--m_nRefs <= 0) FX_Free(this); }
 
-    struct CFX_StringData*      m_pData;
+        intptr_t        m_nRefs;  // Would prefer ssize_t, but no windows support.

[Lei Zhang, 2015/05/14 19:28:39]

kill tabs

[Tom Sepez, 2015/05/14 19:54:43]

Done.

+        FX_STRSIZE      m_nDataLength;
+        FX_STRSIZE      m_nAllocLength;
+        FX_CHAR         m_String[1];
+
+    private:
+        StringData(FX_STRSIZE dataLen, FX_STRSIZE allocLen)
+                    : m_nRefs(1), m_nDataLength(dataLen), m_nAllocLength(allocLen) {

[Lei Zhang, 2015/05/14 19:28:39]

nit: too many spaces here?

[Lei Zhang, 2015/05/14 20:50:14]

Shouldn't it be 4 spaces from the start of "StringData" ?

[Tom Sepez, 2015/05/14 21:25:06]

Should be a double-indent from the start of "StringData", where indent=4 is the
prevailing theme of the file == 8.

+            m_String[dataLen] = 0;

[Lei Zhang, 2015/05/14 19:28:39]

I hate the fact that FX_STRSIZE is signed. Should we make sure this is not
negative?

[Tom Sepez, 2015/05/14 19:54:43]

Yes.

+        }
+    };
+
     void                                        AllocCopy(CFX_ByteString& dest, FX_STRSIZE nCopyLen, FX_STRSIZE nCopyIndex) const;
     void                                        AssignCopy(FX_STRSIZE nSrcLen, FX_LPCSTR lpszSrcData);
     void                                        ConcatCopy(FX_STRSIZE nSrc1Len, FX_LPCSTR lpszSrc1Data, FX_STRSIZE nSrc2Len, FX_LPCSTR lpszSrc2Data);
     void                                        ConcatInPlace(FX_STRSIZE nSrcLen, FX_LPCSTR lpszSrcData);
     void                                        CopyBeforeWrite();
     void                                        AllocBeforeWrite(FX_STRSIZE nLen);
+
+    StringData* m_pData;
 };
 inline CFX_ByteStringC::CFX_ByteStringC(const CFX_ByteString& src)
 {
     m_Ptr = (FX_LPCBYTE)src;
     m_Length = src.GetLength();
 }
 inline CFX_ByteStringC& CFX_ByteStringC::operator = (const CFX_ByteString& src)
 {
     m_Ptr = (FX_LPCBYTE)src;
     m_Length = src.GetLength();
@@ skipping 206 matching lines @@
 };
 inline bool operator== (const wchar_t* lhs, const CFX_WideStringC& rhs) {
     return rhs == lhs;
 }
 inline bool operator!= (const wchar_t* lhs, const CFX_WideStringC& rhs) {
     return rhs != lhs;
 }
 typedef const CFX_WideStringC&  FX_WSTR;
 #define FX_WSTRC(wstr) CFX_WideStringC(wstr, FX_ArraySize(wstr) - 1)
 
-struct CFX_StringDataW {
-    intptr_t    m_nRefs;  // Would prefer ssize_t, but no windows support.
-    FX_STRSIZE  m_nDataLength;
-    FX_STRSIZE  m_nAllocLength;
-    FX_WCHAR    m_String[1];
-};
-
 // A mutable string with shared buffers using copy-on-write semantics that
 // avoids the cost of std::string's iterator stability guarantees.
 class CFX_WideString
 {
 public:
     typedef FX_WCHAR value_type;
 
     CFX_WideString()
     {
         m_pData = NULL;
@@ skipping 150 matching lines @@
 
     FX_STRSIZE                          Remove(FX_WCHAR ch);
 
     CFX_ByteString                      UTF8Encode() const;
 
     CFX_ByteString                      UTF16LE_Encode() const;
 
     void                                        ConvertFrom(const CFX_ByteString& str, CFX_CharMap* pCharMap = NULL);
 
 protected:
+    class StringData {

[Lei Zhang, 2015/05/14 19:28:39]

Hey, this one is a class! :-P

[Tom Sepez, 2015/05/14 19:54:43]

So much for consistency.

+    public:
+        static StringData* Create(int nLen);
+        void Retain() { ++m_nRefs; }
+        void Release() { if (--m_nRefs <= 0) FX_Free(this); }
+
+        intptr_t        m_nRefs;  // Would prefer ssize_t, but no windows support.
+        FX_STRSIZE      m_nDataLength;
+        FX_STRSIZE      m_nAllocLength;
+        FX_WCHAR        m_String[1];
+
+    private:
+        StringData(FX_STRSIZE dataLen, FX_STRSIZE allocLen)
+                    : m_nRefs(1), m_nDataLength(dataLen), m_nAllocLength(allocLen) {
+            m_String[dataLen] = 0;
+        }
+    };
+

[Tom Sepez, 2015/05/14 19:54:43]

Dawns on me that this should have a ~StringData() = delete; to avoid deleting
this malloc'd item.

     void                                        CopyBeforeWrite();
     void                                        AllocBeforeWrite(FX_STRSIZE nLen);
     void                                        ConcatInPlace(FX_STRSIZE nSrcLen, FX_LPCWSTR lpszSrcData);
     void                                        ConcatCopy(FX_STRSIZE nSrc1Len, FX_LPCWSTR lpszSrc1Data, FX_STRSIZE nSrc2Len, FX_LPCWSTR lpszSrc2Data);
     void                                        AssignCopy(FX_STRSIZE nSrcLen, FX_LPCWSTR lpszSrcData);
     void                                        AllocCopy(CFX_WideString& dest, FX_STRSIZE nCopyLen, FX_STRSIZE nCopyIndex) const;
 
-    CFX_StringDataW*            m_pData;
+    StringData* m_pData;
 };
 inline CFX_WideStringC::CFX_WideStringC(const CFX_WideString& src)
 {
     m_Ptr = src.c_str();
     m_Length = src.GetLength();
 }
 inline CFX_WideStringC& CFX_WideStringC::operator = (const CFX_WideString& src)
 {
     m_Ptr = src.c_str();
     m_Length = src.GetLength();
@@ skipping 66 matching lines @@
 CFX_ByteString  FX_UTF8Encode(FX_LPCWSTR pwsStr, FX_STRSIZE len);
 inline CFX_ByteString   FX_UTF8Encode(FX_WSTR wsStr)
 {
     return FX_UTF8Encode(wsStr.GetPtr(), wsStr.GetLength());
 }
 inline CFX_ByteString   FX_UTF8Encode(const CFX_WideString &wsStr)
 {
     return FX_UTF8Encode(wsStr.c_str(), wsStr.GetLength());
 }
 #endif