Remove FX_BOOL from xfa.

xfa/fgas/crt/fgas_utils.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 "xfa/fgas/crt/fgas_utils.h"
 
 #include <algorithm>
 
@@ skipping 20 matching lines @@
 
 FX_BASEARRAYDATA::~FX_BASEARRAYDATA() {
   FX_Free(pBuffer);
 }
 
 CFX_BaseArray::CFX_BaseArray(int32_t iGrowSize, int32_t iBlockSize) {
   ASSERT(iGrowSize > 0 && iBlockSize > 0);
   m_pData = new FX_BASEARRAYDATA(iGrowSize, iBlockSize);
 }
 CFX_BaseArray::~CFX_BaseArray() {
-  RemoveAll(FALSE);
+  RemoveAll(false);
   delete m_pData;
 }
 int32_t CFX_BaseArray::GetSize() const {
   return m_pData->iBlockCount;
 }
 int32_t CFX_BaseArray::GetBlockSize() const {
   return m_pData->iBlockSize;
 }
 uint8_t* CFX_BaseArray::AddSpaceTo(int32_t index) {
   ASSERT(index > -1);
@@ skipping 55 matching lines @@
   ASSERT(iStart > -1 && iStart < iCopied);
   if (iCount < 0) {
     iCount = iCopied;
   }
   if (iStart + iCount > iCopied) {
     iCount = iCopied - iStart;
   }
   if (iCount < 1) {
     return 0;
   }
-  RemoveAll(TRUE);
+  RemoveAll(true);
   AddSpaceTo(iCount - 1);
   FXSYS_memcpy(m_pData->pBuffer, src.m_pData->pBuffer + iStart * iBlockSize,
                iCount * iBlockSize);
   return iCount;
 }
 int32_t CFX_BaseArray::RemoveLast(int32_t iCount) {
   int32_t& iBlockCount = m_pData->iBlockCount;
   if (iCount < 0 || iCount > iBlockCount) {
     iCount = iBlockCount;
     iBlockCount = 0;
   } else {
     iBlockCount -= iCount;
   }
   return iCount;
 }
-void CFX_BaseArray::RemoveAll(FX_BOOL bLeaveMemory) {
+void CFX_BaseArray::RemoveAll(bool bLeaveMemory) {
   if (!bLeaveMemory) {
     uint8_t*& pBuffer = m_pData->pBuffer;
     if (pBuffer) {
       FX_Free(pBuffer);
       pBuffer = nullptr;
     }
     m_pData->iTotalCount = 0;
   }
   m_pData->iBlockCount = 0;
 }
 
 CFX_BaseMassArrayImp::CFX_BaseMassArrayImp(int32_t iChunkSize,
                                            int32_t iBlockSize)
     : m_iChunkSize(iChunkSize),
       m_iBlockSize(iBlockSize),
       m_iChunkCount(0),
       m_iBlockCount(0),
       m_pData(new CFX_ArrayTemplate<void*>()) {
   ASSERT(m_iChunkSize > 0 && m_iBlockSize > 0);
   m_pData->SetSize(16);
 }
 CFX_BaseMassArrayImp::~CFX_BaseMassArrayImp() {
-  RemoveAll(FALSE);
+  RemoveAll(false);
   delete m_pData;
 }
 uint8_t* CFX_BaseMassArrayImp::AddSpaceTo(int32_t index) {
   ASSERT(index > -1);
   uint8_t* pChunk;
   if (index < m_iBlockCount) {
     pChunk = (uint8_t*)m_pData->GetAt(index / m_iChunkSize);
   } else {
     int32_t iMemSize = m_iChunkSize * m_iBlockSize;
-    while (TRUE) {
+    while (true) {
       if (index < m_iChunkCount * m_iChunkSize) {
         pChunk = (uint8_t*)m_pData->GetAt(index / m_iChunkSize);
         break;
       } else {
         pChunk = FX_Alloc(uint8_t, iMemSize);
         if (m_iChunkCount < m_pData->GetSize()) {
           m_pData->SetAt(m_iChunkCount, pChunk);
         } else {
           m_pData->Add(pChunk);
         }
@@ skipping 34 matching lines @@
 }
 int32_t CFX_BaseMassArrayImp::Copy(const CFX_BaseMassArrayImp& src,
                                    int32_t iStart,
                                    int32_t iCount) {
   ASSERT(m_iBlockSize == src.m_iBlockSize);
   int32_t iCopied = src.m_iBlockCount;
   ASSERT(iStart > -1);
   if (iStart >= iCopied) {
     return 0;
   }
-  RemoveAll(TRUE);
+  RemoveAll(true);
   if (iCount < 0) {
     iCount = iCopied;
   }
   if (iStart + iCount > iCopied) {
     iCount = iCopied - iStart;
   }
   if (iCount < 1) {
     return 0;
   }
   if (m_iBlockCount < iCount) {
@@ skipping 50 matching lines @@
   }
 }
 int32_t CFX_BaseMassArrayImp::RemoveLast(int32_t iCount) {
   if (iCount < 0 || iCount >= m_iBlockCount) {
     m_iBlockCount = 0;
   } else {
     m_iBlockCount -= iCount;
   }
   return m_iBlockCount;
 }
-void CFX_BaseMassArrayImp::RemoveAll(FX_BOOL bLeaveMemory) {
+void CFX_BaseMassArrayImp::RemoveAll(bool bLeaveMemory) {
   if (bLeaveMemory) {
     m_iBlockCount = 0;
     return;
   }
   for (int32_t i = 0; i < m_iChunkCount; i++)
     FX_Free(m_pData->GetAt(i));
 
   m_pData->RemoveAll();
   m_iChunkCount = 0;
   m_iBlockCount = 0;
@@ skipping 19 matching lines @@
   return m_pData->Append(*(CFX_BaseMassArrayImp*)src.m_pData, iStart, iCount);
 }
 int32_t CFX_BaseMassArray::Copy(const CFX_BaseMassArray& src,
                                 int32_t iStart,
                                 int32_t iCount) {
   return m_pData->Copy(*(CFX_BaseMassArrayImp*)src.m_pData, iStart, iCount);
 }
 int32_t CFX_BaseMassArray::RemoveLast(int32_t iCount) {
   return m_pData->RemoveLast(iCount);
 }
-void CFX_BaseMassArray::RemoveAll(FX_BOOL bLeaveMemory) {
+void CFX_BaseMassArray::RemoveAll(bool bLeaveMemory) {
   m_pData->RemoveAll(bLeaveMemory);
 }
 
 struct FX_BASEDISCRETEARRAYDATA {
   int32_t iBlockSize;
   int32_t iChunkSize;
   int32_t iChunkCount;
   CFX_ArrayTemplate<uint8_t*> ChunkBuffer;
 };
 
@@ skipping 77 matching lines @@
     return nullptr;
   }
   return m_pData->GetAt(iSize - 1);
 }
 int32_t CFX_BaseStack::GetSize() const {
   return m_pData->m_iBlockCount;
 }
 uint8_t* CFX_BaseStack::GetAt(int32_t index) const {
   return m_pData->GetAt(index);
 }
-void CFX_BaseStack::RemoveAll(FX_BOOL bLeaveMemory) {
+void CFX_BaseStack::RemoveAll(bool bLeaveMemory) {
   m_pData->RemoveAll(bLeaveMemory);
 }