Remove FX_BOOL from core

core/fxcodec/codec/fx_codec_flate.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 "core/fxcodec/codec/codec_int.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 76 matching lines @@
 }  // extern "C"
 
 namespace {
 
 class CLZWDecoder {
  public:
   int Decode(uint8_t* output,
              uint32_t& outlen,
              const uint8_t* input,
              uint32_t& size,
-             FX_BOOL bEarlyChange);
+             bool bEarlyChange);
 
  private:
   void AddCode(uint32_t prefix_code, uint8_t append_char);
   void DecodeString(uint32_t code);
 
   uint32_t m_InPos;
   uint32_t m_OutPos;
   uint8_t* m_pOutput;
   const uint8_t* m_pInput;
-  FX_BOOL m_Early;
+  bool m_Early;
   uint32_t m_CodeArray[5021];
   uint32_t m_nCodes;
   uint8_t m_DecodeStack[4000];
   uint32_t m_StackLen;
   int m_CodeLen;
 };
 
 void CLZWDecoder::AddCode(uint32_t prefix_code, uint8_t append_char) {
   if (m_nCodes + m_Early == 4094) {
     return;
@@ skipping 22 matching lines @@
   }
   if (m_StackLen >= sizeof(m_DecodeStack)) {
     return;
   }
   m_DecodeStack[m_StackLen++] = (uint8_t)code;
 }
 int CLZWDecoder::Decode(uint8_t* dest_buf,
                         uint32_t& dest_size,
                         const uint8_t* src_buf,
                         uint32_t& src_size,
-                        FX_BOOL bEarlyChange) {
+                        bool bEarlyChange) {
   m_CodeLen = 9;
   m_InPos = 0;
   m_OutPos = 0;
   m_pInput = src_buf;
   m_pOutput = dest_buf;
   m_Early = bEarlyChange ? 1 : 0;
   m_nCodes = 0;
   uint32_t old_code = (uint32_t)-1;
   uint8_t last_char = 0;
   while (1) {
@@ skipping 174 matching lines @@
         pDestData[byte] = raw_byte + PathPredictor(left, up, upper_left);
         break;
       }
       default:
         pDestData[byte] = raw_byte;
         break;
     }
   }
 }
 
-FX_BOOL PNG_Predictor(uint8_t*& data_buf,
-                      uint32_t& data_size,
-                      int Colors,
-                      int BitsPerComponent,
-                      int Columns) {
+bool PNG_Predictor(uint8_t*& data_buf,
+                   uint32_t& data_size,
+                   int Colors,
+                   int BitsPerComponent,
+                   int Columns) {
   const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
   const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
   if (row_size <= 0)
-    return FALSE;
+    return false;
   const int row_count = (data_size + row_size) / (row_size + 1);
   if (row_count <= 0)
-    return FALSE;
+    return false;
   const int last_row_size = data_size % (row_size + 1);
   uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size, row_count);
   int byte_cnt = 0;
   uint8_t* pSrcData = data_buf;
   uint8_t* pDestData = dest_buf;
   for (int row = 0; row < row_count; row++) {
     uint8_t tag = pSrcData[0];
     byte_cnt++;
     if (tag == 0) {
       int move_size = row_size;
@@ skipping 59 matching lines @@
       }
       byte_cnt++;
     }
     pSrcData += row_size + 1;
     pDestData += row_size;
   }
   FX_Free(data_buf);
   data_buf = dest_buf;
   data_size = row_size * row_count -
               (last_row_size > 0 ? (row_size + 1 - last_row_size) : 0);
-  return TRUE;
+  return true;
 }
 
 void TIFF_PredictLine(uint8_t* dest_buf,
                       uint32_t row_size,
                       int BitsPerComponent,
                       int Colors,
                       int Columns) {
   if (BitsPerComponent == 1) {
     int row_bits = std::min(BitsPerComponent * Colors * Columns,
                             pdfium::base::checked_cast<int>(row_size * 8));
@@ skipping 22 matching lines @@
       dest_buf[i] = pixel >> 8;
       dest_buf[i + 1] = (uint8_t)pixel;
     }
   } else {
     for (uint32_t i = BytesPerPixel; i < row_size; i++) {
       dest_buf[i] += dest_buf[i - BytesPerPixel];
     }
   }
 }
 
-FX_BOOL TIFF_Predictor(uint8_t*& data_buf,
-                       uint32_t& data_size,
-                       int Colors,
-                       int BitsPerComponent,
-                       int Columns) {
+bool TIFF_Predictor(uint8_t*& data_buf,
+                    uint32_t& data_size,
+                    int Colors,
+                    int BitsPerComponent,
+                    int Columns) {
   int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
   if (row_size == 0)
-    return FALSE;
+    return false;
   const int row_count = (data_size + row_size - 1) / row_size;
   const int last_row_size = data_size % row_size;
   for (int row = 0; row < row_count; row++) {
     uint8_t* scan_line = data_buf + row * row_size;
     if ((row + 1) * row_size > (int)data_size) {
       row_size = last_row_size;
     }
     TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
   }
-  return TRUE;
+  return true;
 }
 
 void FlateUncompress(const uint8_t* src_buf,
                      uint32_t src_size,
                      uint32_t orig_size,
                      uint8_t*& dest_buf,
                      uint32_t& dest_size,
                      uint32_t& offset) {
   uint32_t guess_size = orig_size ? orig_size : src_size * 2;
   const uint32_t kStepSize = 10240;
@@ skipping 113 matching lines @@
               int width,
               int height,
               int nComps,
               int bpc,
               int predictor,
               int Colors,
               int BitsPerComponent,
               int Columns);
 
   // CCodec_ScanlineDecoder
-  FX_BOOL v_Rewind() override;
+  bool v_Rewind() override;
   uint8_t* v_GetNextLine() override;
   uint32_t GetSrcOffset() override;
 
   void* m_pFlate;
   const uint8_t* m_SrcBuf;
   uint32_t m_SrcSize;
   uint8_t* m_pScanline;
   uint8_t* m_pLastLine;
   uint8_t* m_pPredictBuffer;
   uint8_t* m_pPredictRaw;
@@ skipping 59 matching lines @@
       m_PredictPitch =
           (static_cast<uint32_t>(m_BitsPerComponent) * m_Colors * m_Columns +
            7) /
           8;
       m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch);
       m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1);
       m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch);
     }
   }
 }
-FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind() {
+bool CCodec_FlateScanlineDecoder::v_Rewind() {
   if (m_pFlate) {
     FPDFAPI_FlateEnd(m_pFlate);
   }
   m_pFlate = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
   if (!m_pFlate) {
-    return FALSE;
+    return false;
   }
   FPDFAPI_FlateInput(m_pFlate, m_SrcBuf, m_SrcSize);
   m_LeftOver = 0;
-  return TRUE;
+  return true;
 }
 uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine() {
   if (m_Predictor) {
     if (m_Pitch == m_PredictPitch) {
       if (m_Predictor == 2) {
         FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1);
         PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine,
                         m_BitsPerComponent, m_Colors, m_Columns);
         FXSYS_memcpy(m_pLastLine, m_pScanline, m_PredictPitch);
       } else {
@@ skipping 49 matching lines @@
     int bpc,
     int predictor,
     int Colors,
     int BitsPerComponent,
     int Columns) {
   CCodec_FlateScanlineDecoder* pDecoder = new CCodec_FlateScanlineDecoder;
   pDecoder->Create(src_buf, src_size, width, height, nComps, bpc, predictor,
                    Colors, BitsPerComponent, Columns);
   return pDecoder;
 }
-uint32_t CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW,
+uint32_t CCodec_FlateModule::FlateOrLZWDecode(bool bLZW,
                                               const uint8_t* src_buf,
                                               uint32_t src_size,
-                                              FX_BOOL bEarlyChange,
+                                              bool bEarlyChange,
                                               int predictor,
                                               int Colors,
                                               int BitsPerComponent,
                                               int Columns,
                                               uint32_t estimated_size,
                                               uint8_t*& dest_buf,
                                               uint32_t& dest_size) {
   dest_buf = nullptr;
   uint32_t offset = 0;
   int predictor_type = 0;
@@ skipping 21 matching lines @@
       dest_buf[dest_size] = '\0';
       decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange);
     }
   } else {
     FlateUncompress(src_buf, src_size, estimated_size, dest_buf, dest_size,
                     offset);
   }
   if (predictor_type == 0) {
     return offset;
   }
-  FX_BOOL ret = TRUE;
+  bool ret = true;
   if (predictor_type == 2) {
     ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, Columns);
   } else if (predictor_type == 1) {
     ret =
         TIFF_Predictor(dest_buf, dest_size, Colors, BitsPerComponent, Columns);
   }
   return ret ? offset : FX_INVALID_OFFSET;
 }
 
 bool CCodec_FlateModule::Encode(const uint8_t* src_buf,
@@ skipping 14 matching lines @@
                                    uint32_t src_size,
                                    uint8_t** dest_buf,
                                    uint32_t* dest_size) {
   uint8_t* pSrcBuf = FX_Alloc(uint8_t, src_size);
   FXSYS_memcpy(pSrcBuf, src_buf, src_size);
   PNG_PredictorEncode(&pSrcBuf, &src_size);
   bool ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
   FX_Free(pSrcBuf);
   return ret;
 }