Make code compile with clang_use_chrome_plugin (part II)

core/fxcrt/include/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 CORE_FXCRT_INCLUDE_FX_STRING_H_
 #define CORE_FXCRT_INCLUDE_FX_STRING_H_
 
 #include <stdint.h>  // For intptr_t.
@@ skipping 16 matching lines @@
    ((uint32_t)c4))
 
 #define FX_WSTRC(wstr) CFX_WideStringC(wstr, FX_ArraySize(wstr) - 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:
   using CharType = FX_CHAR;
 
-  CFX_ByteString() {}
-  CFX_ByteString(const CFX_ByteString& other) : m_pData(other.m_pData) {}
-  CFX_ByteString(CFX_ByteString&& other) { m_pData.Swap(other.m_pData); }
+  CFX_ByteString();
+  CFX_ByteString(const CFX_ByteString& other);
+  CFX_ByteString(CFX_ByteString&& other);
 
   // Deliberately implicit to avoid calling on every string literal.
   CFX_ByteString(char ch);
-  CFX_ByteString(const FX_CHAR* ptr)
-      : CFX_ByteString(ptr, ptr ? FXSYS_strlen(ptr) : 0) {}
+  CFX_ByteString(const FX_CHAR* ptr);
 
   CFX_ByteString(const FX_CHAR* ptr, FX_STRSIZE len);
   CFX_ByteString(const uint8_t* ptr, FX_STRSIZE len);
 
   explicit CFX_ByteString(const CFX_ByteStringC& bstrc);
   CFX_ByteString(const CFX_ByteStringC& bstrc1, const CFX_ByteStringC& bstrc2);
 
   ~CFX_ByteString();
 
-  void clear() { m_pData.Reset(); }
+  void clear();
 
   static CFX_ByteString FromUnicode(const FX_WCHAR* ptr, FX_STRSIZE len = -1);
   static CFX_ByteString FromUnicode(const CFX_WideString& str);
 
   // Explicit conversion to C-style string.
   // Note: Any subsequent modification of |this| will invalidate the result.
-  const FX_CHAR* c_str() const { return m_pData ? m_pData->m_String : ""; }
+  const FX_CHAR* c_str() const;
 
   // Explicit conversion to uint8_t*.
   // Note: Any subsequent modification of |this| will invalidate the result.
-  const uint8_t* raw_str() const {
-    return m_pData ? reinterpret_cast<const uint8_t*>(m_pData->m_String)
-                   : nullptr;
-  }
+  const uint8_t* raw_str() const;
 
   // Explicit conversion to CFX_ByteStringC.
   // Note: Any subsequent modification of |this| will invalidate the result.
-  CFX_ByteStringC AsStringC() const {
-    return CFX_ByteStringC(raw_str(), GetLength());
-  }
+  CFX_ByteStringC AsStringC() const;
 
-  FX_STRSIZE GetLength() const { return m_pData ? m_pData->m_nDataLength : 0; }
-  bool IsEmpty() const { return !GetLength(); }
+  FX_STRSIZE GetLength() const;
+  bool IsEmpty() const;
 
   int Compare(const CFX_ByteStringC& str) const;
   bool EqualNoCase(const CFX_ByteStringC& str) const;
 
   bool operator==(const char* ptr) const;
   bool operator==(const CFX_ByteStringC& str) const;
   bool operator==(const CFX_ByteString& other) const;
 
-  bool operator!=(const char* ptr) const { return !(*this == ptr); }
-  bool operator!=(const CFX_ByteStringC& str) const { return !(*this == str); }
-  bool operator!=(const CFX_ByteString& other) const {
-    return !(*this == other);
-  }
+  bool operator!=(const char* ptr) const;
+  bool operator!=(const CFX_ByteStringC& str) const;
+  bool operator!=(const CFX_ByteString& other) const;
 
-  bool operator<(const CFX_ByteString& str) const {
-    int result = FXSYS_memcmp(c_str(), str.c_str(),
-                              std::min(GetLength(), str.GetLength()));
-    return result < 0 || (result == 0 && GetLength() < str.GetLength());
-  }
+  bool operator<(const CFX_ByteString& str) const;
 
   const CFX_ByteString& operator=(const FX_CHAR* str);
   const CFX_ByteString& operator=(const CFX_ByteStringC& bstrc);
   const CFX_ByteString& operator=(const CFX_ByteString& stringSrc);
 
   const CFX_ByteString& operator+=(FX_CHAR ch);
   const CFX_ByteString& operator+=(const FX_CHAR* str);
   const CFX_ByteString& operator+=(const CFX_ByteString& str);
   const CFX_ByteString& operator+=(const CFX_ByteStringC& bstrc);
 
-  uint8_t GetAt(FX_STRSIZE nIndex) const {
-    return m_pData ? m_pData->m_String[nIndex] : 0;
-  }
+  uint8_t GetAt(FX_STRSIZE nIndex) const;
 
-  uint8_t operator[](FX_STRSIZE nIndex) const {
-    return m_pData ? m_pData->m_String[nIndex] : 0;
-  }
+  uint8_t operator[](FX_STRSIZE nIndex) const;
 
   void SetAt(FX_STRSIZE nIndex, FX_CHAR ch);
   FX_STRSIZE Insert(FX_STRSIZE index, FX_CHAR ch);
   FX_STRSIZE Delete(FX_STRSIZE index, FX_STRSIZE count = 1);
 
   void Format(const FX_CHAR* lpszFormat, ...);
   void FormatV(const FX_CHAR* lpszFormat, va_list argList);
 
   void Reserve(FX_STRSIZE len);
   FX_CHAR* GetBuffer(FX_STRSIZE len);
@@ skipping 107 matching lines @@
                                 const CFX_ByteString& str2) {
   return CFX_ByteString(str1, str2.AsStringC());
 }
 
 // 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:
   using CharType = FX_WCHAR;
 
-  CFX_WideString() {}
-  CFX_WideString(const CFX_WideString& other) : m_pData(other.m_pData) {}
-  CFX_WideString(CFX_WideString&& other) { m_pData.Swap(other.m_pData); }
+  CFX_WideString();
+  CFX_WideString(const CFX_WideString& other);
+  CFX_WideString(CFX_WideString&& other);
 
   // Deliberately implicit to avoid calling on every string literal.
   CFX_WideString(FX_WCHAR ch);
-  CFX_WideString(const FX_WCHAR* ptr)
-      : CFX_WideString(ptr, ptr ? FXSYS_wcslen(ptr) : 0) {}
+  CFX_WideString(const FX_WCHAR* ptr);
 
   CFX_WideString(const FX_WCHAR* ptr, FX_STRSIZE len);
 
   explicit CFX_WideString(const CFX_WideStringC& str);
   CFX_WideString(const CFX_WideStringC& str1, const CFX_WideStringC& str2);
 
   ~CFX_WideString();
 
   static CFX_WideString FromLocal(const CFX_ByteStringC& str);
   static CFX_WideString FromCodePage(const CFX_ByteStringC& str,
                                      uint16_t codepage);
 
   static CFX_WideString FromUTF8(const CFX_ByteStringC& str);
   static CFX_WideString FromUTF16LE(const unsigned short* str, FX_STRSIZE len);
 
   static FX_STRSIZE WStringLength(const unsigned short* str);
 
   // Explicit conversion to C-style wide string.
   // Note: Any subsequent modification of |this| will invalidate the result.
-  const FX_WCHAR* c_str() const { return m_pData ? m_pData->m_String : L""; }
+  const FX_WCHAR* c_str() const;
 
   // Explicit conversion to CFX_WideStringC.
   // Note: Any subsequent modification of |this| will invalidate the result.
-  CFX_WideStringC AsStringC() const {
-    return CFX_WideStringC(c_str(), GetLength());
-  }
+  CFX_WideStringC AsStringC() const;
 
-  void clear() { m_pData.Reset(); }
+  void clear();
 
-  FX_STRSIZE GetLength() const { return m_pData ? m_pData->m_nDataLength : 0; }
-  bool IsEmpty() const { return !GetLength(); }
+  FX_STRSIZE GetLength() const;
+  bool IsEmpty() const;
 
   const CFX_WideString& operator=(const FX_WCHAR* str);
   const CFX_WideString& operator=(const CFX_WideString& stringSrc);
   const CFX_WideString& operator=(const CFX_WideStringC& stringSrc);
 
   const CFX_WideString& operator+=(const FX_WCHAR* str);
   const CFX_WideString& operator+=(FX_WCHAR ch);
   const CFX_WideString& operator+=(const CFX_WideString& str);
   const CFX_WideString& operator+=(const CFX_WideStringC& str);
 
   bool operator==(const wchar_t* ptr) const;
   bool operator==(const CFX_WideStringC& str) const;
   bool operator==(const CFX_WideString& other) const;
 
-  bool operator!=(const wchar_t* ptr) const { return !(*this == ptr); }
-  bool operator!=(const CFX_WideStringC& str) const { return !(*this == str); }
-  bool operator!=(const CFX_WideString& other) const {
-    return !(*this == other);
-  }
+  bool operator!=(const wchar_t* ptr) const;
+  bool operator!=(const CFX_WideStringC& str) const;
+  bool operator!=(const CFX_WideString& other) const;
 
-  bool operator<(const CFX_WideString& str) const {
-    int result =
-        wmemcmp(c_str(), str.c_str(), std::min(GetLength(), str.GetLength()));
-    return result < 0 || (result == 0 && GetLength() < str.GetLength());
-  }
+  bool operator<(const CFX_WideString& str) const;
 
-  FX_WCHAR GetAt(FX_STRSIZE nIndex) const {
-    return m_pData ? m_pData->m_String[nIndex] : 0;
-  }
+  FX_WCHAR GetAt(FX_STRSIZE nIndex) const;
 
-  FX_WCHAR operator[](FX_STRSIZE nIndex) const {
-    return m_pData ? m_pData->m_String[nIndex] : 0;
-  }
+  FX_WCHAR operator[](FX_STRSIZE nIndex) const;
 
   void SetAt(FX_STRSIZE nIndex, FX_WCHAR ch);
 
   int Compare(const FX_WCHAR* str) const;
   int Compare(const CFX_WideString& str) const;
   int CompareNoCase(const FX_WCHAR* str) const;
 
 
   CFX_WideString Mid(FX_STRSIZE first) const;
   CFX_WideString Mid(FX_STRSIZE first, FX_STRSIZE count) const;
@@ skipping 113 matching lines @@
 }
 
 FX_FLOAT FX_atof(const CFX_ByteStringC& str);
 inline FX_FLOAT FX_atof(const CFX_WideStringC& wsStr) {
   return FX_atof(FX_UTF8Encode(wsStr.c_str(), wsStr.GetLength()).c_str());
 }
 void FX_atonum(const CFX_ByteStringC& str, FX_BOOL& bInteger, void* pData);
 FX_STRSIZE FX_ftoa(FX_FLOAT f, FX_CHAR* buf);
 
 #endif  // CORE_FXCRT_INCLUDE_FX_STRING_H_