Remove FX_BOOL from core

core/fxcodec/codec/fx_codec_fax.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 <algorithm>
 #include <vector>
 
 #include "core/fxcodec/codec/codec_int.h"
@@ skipping 255 matching lines @@
     ++(*bitpos);
     int next_off = ins_off + ins * 3;
     for (; ins_off < next_off; ins_off += 3) {
       if (ins_array[ins_off] == code) {
         return ins_array[ins_off + 1] + ins_array[ins_off + 2] * 256;
       }
     }
   }
 }
 
-FX_BOOL FaxG4GetRow(const uint8_t* src_buf,
-                    int bitsize,
-                    int* bitpos,
-                    uint8_t* dest_buf,
-                    const std::vector<uint8_t>& ref_buf,
-                    int columns) {
+bool FaxG4GetRow(const uint8_t* src_buf,
+                 int bitsize,
+                 int* bitpos,
+                 uint8_t* dest_buf,
+                 const std::vector<uint8_t>& ref_buf,
+                 int columns) {
   int a0 = -1;
   bool a0color = true;
   while (1) {
     if (*bitpos >= bitsize)
-      return FALSE;
+      return false;
 
     int a1;
     int a2;
     int b1;
     int b2;
     FaxG4FindB1B2(ref_buf, columns, a0, a0color, &b1, &b2);
 
     int v_delta = 0;
     if (!NextBit(src_buf, bitpos)) {
       if (*bitpos >= bitsize)
-        return FALSE;
+        return false;
 
-      FX_BOOL bit1 = NextBit(src_buf, bitpos);
+      bool bit1 = NextBit(src_buf, bitpos);
       if (*bitpos >= bitsize)
-        return FALSE;
+        return false;
 
-      FX_BOOL bit2 = NextBit(src_buf, bitpos);
+      bool bit2 = NextBit(src_buf, bitpos);
       if (bit1) {
         v_delta = bit2 ? 1 : -1;
       } else if (bit2) {
         int run_len1 = 0;
         while (1) {
           int run = FaxGetRun(a0color ? FaxWhiteRunIns : FaxBlackRunIns,
                               src_buf, bitpos, bitsize);
           run_len1 += run;
           if (run < 64) {
             break;
@@ skipping 16 matching lines @@
           }
         }
         a2 = a1 + run_len2;
         if (a0color)
           FaxFillBits(dest_buf, columns, a1, a2);
 
         a0 = a2;
         if (a0 < columns)
           continue;
 
-        return TRUE;
+        return true;
       } else {
         if (*bitpos >= bitsize)
-          return FALSE;
+          return false;
 
         if (NextBit(src_buf, bitpos)) {
           if (!a0color)
             FaxFillBits(dest_buf, columns, a0, b2);
 
           if (b2 >= columns)
-            return TRUE;
+            return true;
 
           a0 = b2;
           continue;
         }
 
         if (*bitpos >= bitsize)
-          return FALSE;
+          return false;
 
-        FX_BOOL next_bit1 = NextBit(src_buf, bitpos);
+        bool next_bit1 = NextBit(src_buf, bitpos);
         if (*bitpos >= bitsize)
-          return FALSE;
+          return false;
 
-        FX_BOOL next_bit2 = NextBit(src_buf, bitpos);
+        bool next_bit2 = NextBit(src_buf, bitpos);
         if (next_bit1) {
           v_delta = next_bit2 ? 2 : -2;
         } else if (next_bit2) {
           if (*bitpos >= bitsize)
-            return FALSE;
+            return false;
 
           v_delta = NextBit(src_buf, bitpos) ? 3 : -3;
         } else {
           if (*bitpos >= bitsize)
-            return FALSE;
+            return false;
 
           if (NextBit(src_buf, bitpos)) {
             *bitpos += 3;
             continue;
           }
           *bitpos += 5;
-          return TRUE;
+          return true;
         }
       }
     }
     a1 = b1 + v_delta;
     if (!a0color)
       FaxFillBits(dest_buf, columns, a0, a1);
 
     if (a1 >= columns)
-      return TRUE;
+      return true;
 
     // The position of picture element must be monotonic increasing.
     if (a0 >= a1)
-      return FALSE;
+      return false;
 
     a0 = a1;
     a0color = !a0color;
   }
 }
 
-FX_BOOL FaxSkipEOL(const uint8_t* src_buf, int bitsize, int* bitpos) {
+bool FaxSkipEOL(const uint8_t* src_buf, int bitsize, int* bitpos) {
   int startbit = *bitpos;
   while (*bitpos < bitsize) {
     if (!NextBit(src_buf, bitpos))
       continue;
     if (*bitpos - startbit <= 11)
       *bitpos = startbit;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL FaxGet1DLine(const uint8_t* src_buf,
-                     int bitsize,
-                     int* bitpos,
-                     std::vector<uint8_t>* dest_buf,
-                     int columns) {
+bool FaxGet1DLine(const uint8_t* src_buf,
+                  int bitsize,
+                  int* bitpos,
+                  std::vector<uint8_t>* dest_buf,
+                  int columns) {
   bool color = true;
   int startpos = 0;
   while (1) {
     if (*bitpos >= bitsize)
-      return FALSE;
+      return false;
 
     int run_len = 0;
     while (1) {
       int run = FaxGetRun(color ? FaxWhiteRunIns : FaxBlackRunIns, src_buf,
                           bitpos, bitsize);
       if (run < 0) {
         while (*bitpos < bitsize) {
           if (NextBit(src_buf, bitpos))
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
       }
       run_len += run;
       if (run < 64) {
         break;
       }
     }
     if (!color)
       FaxFillBits(dest_buf->data(), columns, startpos, startpos + run_len);
 
     startpos += run_len;
     if (startpos >= columns)
       break;
 
     color = !color;
   }
-  return TRUE;
+  return true;
 }
 
 }  // namespace
 
 class CCodec_FaxDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_FaxDecoder(const uint8_t* src_buf,
                     uint32_t src_size,
                     int width,
                     int height,
                     uint32_t pitch,
                     int K,
                     bool EndOfLine,
                     bool EncodedByteAlign,
                     bool BlackIs1);
   ~CCodec_FaxDecoder() override;
 
   // CCodec_ScanlineDecoder
-  FX_BOOL v_Rewind() override;
+  bool v_Rewind() override;
   uint8_t* v_GetNextLine() override;
   uint32_t GetSrcOffset() override;
 
  private:
   const int m_Encoding;
   int m_bitpos;
   bool m_bByteAlign;
   const bool m_bEndOfLine;
   const bool m_bBlack;
   const uint32_t m_SrcSize;
@@ skipping 17 matching lines @@
       m_bByteAlign(EncodedByteAlign),
       m_bEndOfLine(EndOfLine),
       m_bBlack(BlackIs1),
       m_SrcSize(src_size),
       m_pSrcBuf(src_buf),
       m_ScanlineBuf(pitch),
       m_RefBuf(pitch) {}
 
 CCodec_FaxDecoder::~CCodec_FaxDecoder() {}
 
-FX_BOOL CCodec_FaxDecoder::v_Rewind() {
+bool CCodec_FaxDecoder::v_Rewind() {
   FXSYS_memset(m_RefBuf.data(), 0xff, m_RefBuf.size());
   m_bitpos = 0;
-  return TRUE;
+  return true;
 }
 
 uint8_t* CCodec_FaxDecoder::v_GetNextLine() {
   int bitsize = m_SrcSize * 8;
   FaxSkipEOL(m_pSrcBuf, bitsize, &m_bitpos);
   if (m_bitpos >= bitsize)
     return nullptr;
 
   FXSYS_memset(m_ScanlineBuf.data(), 0xff, m_ScanlineBuf.size());
   if (m_Encoding < 0) {
@@ skipping 79 matching lines @@
     return nullptr;
 
   // Reject unreasonable large input.
   if (actual_width > kMaxImageDimension || actual_height > kMaxImageDimension)
     return nullptr;
 
   uint32_t pitch = (static_cast<uint32_t>(actual_width) + 31) / 32 * 4;
   return new CCodec_FaxDecoder(src_buf, src_size, actual_width, actual_height,
                                pitch, K, EndOfLine, EncodedByteAlign, BlackIs1);
 }