Remove FX_BOOL from core

core/fxcrt/fx_basic.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_FX_BASIC_H_
 #define CORE_FXCRT_FX_BASIC_H_
 
 #include <algorithm>
@@ skipping 164 matching lines @@
  protected:
   CFX_ByteTextBuf m_Buffer;
 };
 
 class CFX_BasicArray {
  protected:
   explicit CFX_BasicArray(int unit_size);
   CFX_BasicArray(const CFX_BasicArray&) = delete;
   ~CFX_BasicArray();
 
-  FX_BOOL SetSize(int nNewSize);
-  FX_BOOL Append(const CFX_BasicArray& src);
-  FX_BOOL Copy(const CFX_BasicArray& src);
+  bool SetSize(int nNewSize);
+  bool Append(const CFX_BasicArray& src);
+  bool Copy(const CFX_BasicArray& src);
   uint8_t* InsertSpaceAt(int nIndex, int nCount);
-  FX_BOOL RemoveAt(int nIndex, int nCount);
-  FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
+  bool RemoveAt(int nIndex, int nCount);
+  bool InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
   const void* GetDataPtr(int index) const;
 
  protected:
   uint8_t* m_pData;
   int m_nSize;
   int m_nMaxSize;
   int m_nUnitSize;
 };
 
 template <class TYPE>
 class CFX_ArrayTemplate : public CFX_BasicArray {
  public:
   CFX_ArrayTemplate() : CFX_BasicArray(sizeof(TYPE)) {}
 
   int GetSize() const { return m_nSize; }
 
   int GetUpperBound() const { return m_nSize - 1; }
 
-  FX_BOOL SetSize(int nNewSize) { return CFX_BasicArray::SetSize(nNewSize); }
+  bool SetSize(int nNewSize) { return CFX_BasicArray::SetSize(nNewSize); }
 
   void RemoveAll() { SetSize(0); }
 
   const TYPE GetAt(int nIndex) const {
     if (nIndex < 0 || nIndex >= m_nSize) {
       PDFIUM_IMMEDIATE_CRASH();
     }
     return ((const TYPE*)m_pData)[nIndex];
   }
 
-  FX_BOOL SetAt(int nIndex, TYPE newElement) {
+  bool SetAt(int nIndex, TYPE newElement) {
     if (nIndex < 0 || nIndex >= m_nSize) {
-      return FALSE;
+      return false;
     }
     ((TYPE*)m_pData)[nIndex] = newElement;
-    return TRUE;
+    return true;
   }
 
   TYPE& ElementAt(int nIndex) {
     if (nIndex < 0 || nIndex >= m_nSize) {
       PDFIUM_IMMEDIATE_CRASH();
     }
     return ((TYPE*)m_pData)[nIndex];
   }
 
   const TYPE* GetData() const { return (const TYPE*)m_pData; }
 
   TYPE* GetData() { return (TYPE*)m_pData; }
 
-  FX_BOOL SetAtGrow(int nIndex, TYPE newElement) {
+  bool SetAtGrow(int nIndex, TYPE newElement) {
     if (nIndex < 0)
-      return FALSE;
+      return false;
 
     if (nIndex >= m_nSize && !SetSize(nIndex + 1))
-      return FALSE;
+      return false;
 
     ((TYPE*)m_pData)[nIndex] = newElement;
-    return TRUE;
+    return true;
   }
 
-  FX_BOOL Add(TYPE newElement) {
+  bool Add(TYPE newElement) {
     if (m_nSize < m_nMaxSize) {
       m_nSize++;
     } else if (!SetSize(m_nSize + 1)) {
-      return FALSE;
+      return false;
     }
     ((TYPE*)m_pData)[m_nSize - 1] = newElement;
-    return TRUE;
+    return true;
   }
 
-  FX_BOOL Append(const CFX_ArrayTemplate& src) {
+  bool Append(const CFX_ArrayTemplate& src) {
     return CFX_BasicArray::Append(src);
   }
 
-  FX_BOOL Copy(const CFX_ArrayTemplate& src) {
-    return CFX_BasicArray::Copy(src);
-  }
+  bool Copy(const CFX_ArrayTemplate& src) { return CFX_BasicArray::Copy(src); }
 
   TYPE* GetDataPtr(int index) {
     return (TYPE*)CFX_BasicArray::GetDataPtr(index);
   }
 
   TYPE* AddSpace() { return (TYPE*)CFX_BasicArray::InsertSpaceAt(m_nSize, 1); }
 
   TYPE* InsertSpaceAt(int nIndex, int nCount) {
     return (TYPE*)CFX_BasicArray::InsertSpaceAt(nIndex, nCount);
   }
 
   const TYPE operator[](int nIndex) const {
     if (nIndex < 0 || nIndex >= m_nSize) {
       *(volatile char*)0 = '\0';
     }
     return ((const TYPE*)m_pData)[nIndex];
   }
 
   TYPE& operator[](int nIndex) {
     if (nIndex < 0 || nIndex >= m_nSize) {
       *(volatile char*)0 = '\0';
     }
     return ((TYPE*)m_pData)[nIndex];
   }
 
-  FX_BOOL InsertAt(int nIndex, TYPE newElement, int nCount = 1) {
+  bool InsertAt(int nIndex, TYPE newElement, int nCount = 1) {
     if (!InsertSpaceAt(nIndex, nCount)) {
-      return FALSE;
+      return false;
     }
     while (nCount--) {
       ((TYPE*)m_pData)[nIndex++] = newElement;
     }
-    return TRUE;
+    return true;
   }
 
-  FX_BOOL RemoveAt(int nIndex, int nCount = 1) {
+  bool RemoveAt(int nIndex, int nCount = 1) {
     return CFX_BasicArray::RemoveAt(nIndex, nCount);
   }
 
-  FX_BOOL InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray) {
+  bool InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray) {
     return CFX_BasicArray::InsertAt(nStartIndex, pNewArray);
   }
 
   int Find(TYPE data, int iStart = 0) const {
     if (iStart < 0) {
       return -1;
     }
     for (; iStart < (int)m_nSize; iStart++)
       if (((TYPE*)m_pData)[iStart] == data) {
         return iStart;
@@ skipping 139 matching lines @@
     void* value;
   };
 
  public:
   CFX_MapPtrToPtr(int nBlockSize = 10);
   ~CFX_MapPtrToPtr();
 
   int GetCount() const { return m_nCount; }
   bool IsEmpty() const { return m_nCount == 0; }
 
-  FX_BOOL Lookup(void* key, void*& rValue) const;
+  bool Lookup(void* key, void*& rValue) const;
 
   void* GetValueAt(void* key) const;
 
   void*& operator[](void* key);
 
   void SetAt(void* key, void* newValue) { (*this)[key] = newValue; }
 
-  FX_BOOL RemoveKey(void* key);
+  bool RemoveKey(void* key);
 
   void RemoveAll();
 
   FX_POSITION GetStartPosition() const {
     return m_nCount == 0 ? nullptr : (FX_POSITION)-1;
   }
 
   void GetNextAssoc(FX_POSITION& rNextPosition,
                     void*& rKey,
                     void*& rValue) const;
 
   uint32_t GetHashTableSize() const { return m_nHashTableSize; }
 
-  void InitHashTable(uint32_t hashSize, FX_BOOL bAllocNow = TRUE);
+  void InitHashTable(uint32_t hashSize, bool bAllocNow = true);
 
  protected:
   CAssoc** m_pHashTable;
 
   uint32_t m_nHashTableSize;
 
   int m_nCount;
 
   CAssoc* m_pFreeList;
 
   struct CFX_Plex* m_pBlocks;
 
   int m_nBlockSize;
 
   uint32_t HashKey(void* key) const;
 
   CAssoc* NewAssoc();
 
   void FreeAssoc(CAssoc* pAssoc);
 
   CAssoc* GetAssocAt(void* key, uint32_t& hash) const;
 };
 
 template <class KeyType, class ValueType>
 class CFX_MapPtrTemplate : public CFX_MapPtrToPtr {
  public:
   CFX_MapPtrTemplate() : CFX_MapPtrToPtr(10) {}
 
-  FX_BOOL Lookup(KeyType key, ValueType& rValue) const {
+  bool Lookup(KeyType key, ValueType& rValue) const {
     void* pValue = nullptr;
     if (!CFX_MapPtrToPtr::Lookup((void*)(uintptr_t)key, pValue)) {
-      return FALSE;
+      return false;
     }
     rValue = (ValueType)(uintptr_t)pValue;
-    return TRUE;
+    return true;
   }
 
   ValueType& operator[](KeyType key) {
     return (ValueType&)CFX_MapPtrToPtr::operator[]((void*)(uintptr_t)key);
   }
 
   void SetAt(KeyType key, ValueType newValue) {
     CFX_MapPtrToPtr::SetAt((void*)(uintptr_t)key, (void*)(uintptr_t)newValue);
   }
 
-  FX_BOOL RemoveKey(KeyType key) {
+  bool RemoveKey(KeyType key) {
     return CFX_MapPtrToPtr::RemoveKey((void*)(uintptr_t)key);
   }
 
   void GetNextAssoc(FX_POSITION& rNextPosition,
                     KeyType& rKey,
                     ValueType& rValue) const {
     void* pKey = nullptr;
     void* pValue = nullptr;
     CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
     rKey = (KeyType)(uintptr_t)pKey;
@@ skipping 77 matching lines @@
 #endif  // PDF_ENABLE_XFA
 
 class CFX_BitStream {
  public:
   void Init(const uint8_t* pData, uint32_t dwSize);
 
   uint32_t GetBits(uint32_t nBits);
 
   void ByteAlign();
 
-  FX_BOOL IsEOF() { return m_BitPos >= m_BitSize; }
+  bool IsEOF() { return m_BitPos >= m_BitSize; }
 
   void SkipBits(uint32_t nBits) { m_BitPos += nBits; }
 
   void Rewind() { m_BitPos = 0; }
 
   uint32_t GetPos() const { return m_BitPos; }
 
   uint32_t BitsRemaining() const {
     return m_BitSize >= m_BitPos ? m_BitSize - m_BitPos : 0;
   }
 
  protected:
   uint32_t m_BitPos;
 
   uint32_t m_BitSize;
 
   const uint8_t* m_pData;
 };
 
 class IFX_Pause {
  public:
   virtual ~IFX_Pause() {}
-  virtual FX_BOOL NeedToPauseNow() = 0;
+  virtual bool NeedToPauseNow() = 0;
 };
 
 template <typename T>
 class CFX_AutoRestorer {
  public:
   explicit CFX_AutoRestorer(T* location)
       : m_Location(location), m_OldValue(*location) {}
   ~CFX_AutoRestorer() { *m_Location = m_OldValue; }
 
  private:
@@ skipping 185 matching lines @@
   FX_FLOAT e;
   FX_FLOAT f;
   FX_FLOAT g;
   FX_FLOAT h;
   FX_FLOAT i;
 };
 
 uint32_t GetBits32(const uint8_t* pData, int bitpos, int nbits);
 
 #endif  // CORE_FXCRT_FX_BASIC_H_