Fix issuse with != and == shown by fx_basic_bstring unit tests.

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 76 matching lines @@
 
     CFX_ByteStringC& operator = (const CFX_ByteStringC& src)
     {
         m_Ptr = src.m_Ptr;
         m_Length = src.m_Length;
         return *this;
     }
 
     CFX_ByteStringC& operator = (const CFX_ByteString& src);
 
-    bool                        operator == (const CFX_ByteStringC& str) const
-    {
-        return  str.m_Length == m_Length && FXSYS_memcmp32(str.m_Ptr, m_Ptr, m_Length) == 0;
+    bool operator== (const char* ptr) const {
+        return strlen(ptr) == m_Length &&
+                FXSYS_memcmp32(ptr, m_Ptr, m_Length) == 0;
     }
-
-    bool                        operator != (const CFX_ByteStringC& str) const
-    {
-        return  str.m_Length != m_Length || FXSYS_memcmp32(str.m_Ptr, m_Ptr, m_Length) != 0;
+    bool operator== (const CFX_ByteStringC& other) const {
+        return other.m_Length == m_Length &&
+                FXSYS_memcmp32(other.m_Ptr, m_Ptr, m_Length) == 0;
+    }
+    bool operator!= (const char* ptr) const { return !(*this == ptr); }
+    bool operator!= (const CFX_ByteStringC& other) const {
+        return !(*this == other);
     }
 
     FX_DWORD            GetID(FX_STRSIZE start_pos = 0) const;
 
     FX_LPCBYTE          GetPtr() const
     {
         return m_Ptr;
     }
 
     FX_LPCSTR           GetCStr() const
@@ skipping 44 matching lines @@
 protected:
     FX_LPCBYTE          m_Ptr;
     FX_STRSIZE          m_Length;
 
 private:
     void*                       operator new (size_t) throw()
     {
         return NULL;
     }
 };
+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.
@@ skipping 57 matching lines @@
     }
 
     bool                                        IsEmpty() const
     {
         return !GetLength();
     }
 
     int                                         Compare(FX_BSTR str) const;
 
 
-    bool                                        Equal(FX_BSTR str) const;
+    bool Equal(const char* ptr) const;
+    bool Equal(const CFX_ByteStringC& str) const;
+    bool Equal(const CFX_ByteString& other) const;
 
+    bool EqualNoCase(FX_BSTR str) const;
 
-    bool                                        EqualNoCase(FX_BSTR str) const;
+    bool operator== (const char* ptr) const { return Equal(ptr); }
+    bool operator== (const CFX_ByteStringC& str) const { return Equal(str); }
+    bool operator== (const CFX_ByteString& other) const { return Equal(other); }
 
-    bool                                        operator == (FX_LPCSTR str) const
-    {
-        return Equal(str);
+    bool operator!= (const char* ptr) const { return !(*this == ptr); }
+    bool operator!= (const CFX_ByteStringC& str) const {
+        return !(*this == str);
     }
-
-    bool                                        operator == (FX_BSTR str) const
-    {
-        return Equal(str);
-    }
-
-    bool                                        operator == (const CFX_ByteString& str) const;
-
-    bool                                        operator != (FX_LPCSTR str) const
-    {
-        return !Equal(str);
-    }
-
-    bool                                        operator != (FX_BSTR str) const
-    {
-        return !Equal(str);
-    }
-
-    bool                                        operator != (const CFX_ByteString& str) const
-    {
-        return !operator==(str);
+    bool operator!= (const CFX_ByteString& other) const {
+        return !(*this == other);
     }
 
     bool operator< (const CFX_ByteString& str) const
     {
         int result = FXSYS_memcmp32(c_str(), str.c_str(), std::min(GetLength(), str.GetLength()));
         return result < 0 || (result == 0 && GetLength() < str.GetLength());
     }
 
     void                                        Empty();
 
@@ skipping 105 matching lines @@
     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();
     return *this;
 }
 
+inline bool operator== (const char* lhs, const CFX_ByteString& rhs) {
+    return rhs == lhs;
+}
+inline bool operator== (const CFX_ByteStringC& lhs, const CFX_ByteString& rhs) {
+    return rhs == lhs;
+}
+inline bool operator!= (const char* lhs, const CFX_ByteString& rhs) {
+    return rhs != lhs;
+}
+inline bool operator!= (const CFX_ByteStringC& lhs, const CFX_ByteString& rhs) {
+    return rhs != lhs;
+}
+
 inline CFX_ByteString operator + (FX_BSTR str1, FX_BSTR str2)
 {
     return CFX_ByteString(str1, str2);
 }
 inline CFX_ByteString operator + (FX_BSTR str1, FX_LPCSTR str2)
 {
     return CFX_ByteString(str1, str2);
 }
 inline CFX_ByteString operator + (FX_LPCSTR str1, FX_BSTR str2)
 {
@@ skipping 430 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