FX_BOOL considered harmful.

core/src/fxcodec/codec/codec_int.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_SRC_FXCODEC_CODEC_CODEC_INT_H_
 #define CORE_SRC_FXCODEC_CODEC_CODEC_INT_H_
 
 #include <limits.h>
 #include <list>
 
 #include "../../../../third_party/libopenjpeg20/openjpeg.h"  // For OPJ_SIZE_T.
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../jbig2/JBig2_Context.h"
 
 class CCodec_BasicModule : public ICodec_BasicModule
 {
 public:
-    virtual FX_BOOL     RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
+    virtual bool        RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
                                     FX_DWORD& dest_size);
-    virtual FX_BOOL     A85Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
+    virtual bool        A85Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
                               FX_DWORD& dest_size);
     virtual ICodec_ScanlineDecoder*     CreateRunLengthDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
             int nComps, int bpc);
 };
 struct CCodec_ImageDataCache {
     int                 m_Width, m_Height;
     int                 m_nCachedLines;
     uint8_t             m_Data;
 };
 class CCodec_ScanlineDecoder : public ICodec_ScanlineDecoder
 {
 public:
 
     CCodec_ScanlineDecoder();
 
     virtual ~CCodec_ScanlineDecoder();
 
     virtual FX_DWORD    GetSrcOffset()
     {
         return -1;
     }
 
     virtual void                DownScale(int dest_width, int dest_height);
 
     uint8_t*                    GetScanline(int line);
 
-    FX_BOOL                             SkipToScanline(int line, IFX_Pause* pPause);
+    bool                                SkipToScanline(int line, IFX_Pause* pPause);
 
     int                                 GetWidth()
     {
         return m_OutputWidth;
     }
 
     int                                 GetHeight()
     {
         return m_OutputHeight;
     }
 
     int                                 CountComps()
     {
         return m_nComps;
     }
 
     int                                 GetBPC()
     {
         return m_bpc;
     }
 
-    FX_BOOL                             IsColorTransformed()
+    bool                                IsColorTransformed()
     {
         return m_bColorTransformed;
     }
 
     void                                ClearImageData()
     {
         if (m_pDataCache) {
             FX_Free(m_pDataCache);
         }
         m_pDataCache = NULL;
     }
 protected:
 
     int                                 m_OrigWidth;
 
     int                                 m_OrigHeight;
 
     int                                 m_DownScale;
 
     int                                 m_OutputWidth;
 
     int                                 m_OutputHeight;
 
     int                                 m_nComps;
 
     int                                 m_bpc;
 
     int                                 m_Pitch;
 
-    FX_BOOL                             m_bColorTransformed;
+    bool                                m_bColorTransformed;
 
     uint8_t*                    ReadNextLine();
 
-    virtual FX_BOOL             v_Rewind() = 0;
+    virtual bool                v_Rewind() = 0;
 
     virtual uint8_t*    v_GetNextLine() = 0;
 
     virtual void                v_DownScale(int dest_width, int dest_height) = 0;
 
     int                                 m_NextLine;
 
     uint8_t*                    m_pLastScanline;
 
     CCodec_ImageDataCache*      m_pDataCache;
 };
 class CCodec_FaxModule : public ICodec_FaxModule
 {
 public:
     virtual ICodec_ScanlineDecoder*     CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-            int K, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows);
-    FX_BOOL             Encode(const uint8_t* src_buf, int width, int height, int pitch, uint8_t*& dest_buf, FX_DWORD& dest_size);
+            int K, bool EndOfLine, bool EncodedByteAlign, bool BlackIs1, int Columns, int Rows);
+    bool                Encode(const uint8_t* src_buf, int width, int height, int pitch, uint8_t*& dest_buf, FX_DWORD& dest_size);
 };
 class CCodec_FlateModule : public ICodec_FlateModule
 {
 public:
     virtual ICodec_ScanlineDecoder*     CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
             int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns);
-    virtual FX_DWORD FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, FX_BOOL bEarlyChange,
+    virtual FX_DWORD FlateOrLZWDecode(bool bLZW, const uint8_t* src_buf, FX_DWORD src_size, bool bEarlyChange,
                                       int predictor, int Colors, int BitsPerComponent, int Columns,
                                       FX_DWORD estimated_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
-    virtual FX_BOOL Encode(const uint8_t* src_buf, FX_DWORD src_size,
+    virtual bool Encode(const uint8_t* src_buf, FX_DWORD src_size,
                            int predictor, int Colors, int BitsPerComponent, int Columns,
                            uint8_t*& dest_buf, FX_DWORD& dest_size);
-    virtual FX_BOOL             Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
+    virtual bool                Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
 };
 class CCodec_JpegModule : public ICodec_JpegModule
 {
 public:
     CCodec_JpegModule() : m_pExtProvider(NULL) {}
     void SetPovider(IFX_JpegProvider* pJP)
     {
         m_pExtProvider = pJP;
     }
     ICodec_ScanlineDecoder*     CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size,
-                                          int width, int height, int nComps, FX_BOOL ColorTransform);
-    FX_BOOL             LoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
-                         int& num_components, int& bits_per_components, FX_BOOL& color_transform,
+                                          int width, int height, int nComps, bool ColorTransform);
+    bool                LoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
+                         int& num_components, int& bits_per_components, bool& color_transform,
                          uint8_t** icc_buf_ptr, FX_DWORD* icc_length);
-    FX_BOOL             Encode(const CFX_DIBSource* pSource, uint8_t*& dest_buf, FX_STRSIZE& dest_size, int quality, const uint8_t* icc_buf, FX_DWORD icc_length);
+    bool                Encode(const CFX_DIBSource* pSource, uint8_t*& dest_buf, FX_STRSIZE& dest_size, int quality, const uint8_t* icc_buf, FX_DWORD icc_length);
     virtual void*               Start();
     virtual void                Finish(void* pContext);
     virtual void                Input(void* pContext, const uint8_t* src_buf, FX_DWORD src_size);
     virtual int                 ReadHeader(void* pContext, int* width, int* height, int* nComps);
-    virtual FX_BOOL             StartScanline(void* pContext, int down_scale);
-    virtual FX_BOOL             ReadScanline(void* pContext, uint8_t* dest_buf);
+    virtual int                 StartScanline(void* pContext, int down_scale);
+    virtual bool                ReadScanline(void* pContext, uint8_t* dest_buf);
     virtual FX_DWORD    GetAvailInput(void* pContext, uint8_t** avail_buf_ptr);
 protected:
     IFX_JpegProvider* m_pExtProvider;
 };
 class CCodec_IccModule : public ICodec_IccModule
 {
 public:
     virtual IccCS                       GetProfileCS(const uint8_t* pProfileData, unsigned int dwProfileSize);
     virtual IccCS                       GetProfileCS(IFX_FileRead* pFile);
     virtual void*               CreateTransform(ICodec_IccModule::IccParam* pInputParam,
@@ skipping 25 matching lines @@
         Icc_CLASS_OUTPUT,
         Icc_CLASS_PROOF,
         Icc_CLASS_MAX
     } Icc_CLASS;
     void*               CreateProfile(ICodec_IccModule::IccParam* pIccParam, Icc_CLASS ic, CFX_BinaryBuf* pTransformKey);
 };
 class CCodec_JpxModule : public ICodec_JpxModule
 {
 public:
     CCodec_JpxModule();
-    void*               CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, FX_BOOL useColorSpace = FALSE);
+    void*               CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, bool useColorSpace = false);
     void                GetImageInfo(void* ctx, FX_DWORD& width, FX_DWORD& height,
                              FX_DWORD& codestream_nComps, FX_DWORD& output_nComps);
-    FX_BOOL             Decode(void* ctx, uint8_t* dest_data, int pitch, FX_BOOL bTranslateColor, uint8_t* offsets);
+    bool                Decode(void* ctx, uint8_t* dest_data, int pitch, bool bTranslateColor, uint8_t* offsets);
     void                DestroyDecoder(void* ctx);
 };
 class CPDF_Jbig2Interface : public CJBig2_Module
 {
 public:
     virtual void *JBig2_Malloc(FX_DWORD dwSize)
     {
         return FX_Alloc(uint8_t, dwSize);
     }
     virtual void *JBig2_Malloc2(FX_DWORD num, FX_DWORD dwSize)
@@ skipping 30 matching lines @@
     ~CCodec_Jbig2Context() {};
     IFX_FileRead* m_file_ptr;
     FX_DWORD m_width;
     FX_DWORD m_height;
     uint8_t* m_src_buf;
     FX_DWORD m_src_size;
     const uint8_t* m_global_data;
     FX_DWORD m_global_size;
     uint8_t* m_dest_buf;
     FX_DWORD m_dest_pitch;
-    FX_BOOL     m_bFileReader;
+    bool        m_bFileReader;
     IFX_Pause* m_pPause;
     CJBig2_Context* m_pContext;
     CJBig2_Image* m_dest_image;
 };
 class CCodec_Jbig2Module : public ICodec_Jbig2Module
 {
 public:
     CCodec_Jbig2Module() {};
     ~CCodec_Jbig2Module();
-    FX_BOOL             Decode(FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
+    bool                Decode(FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
                        const uint8_t* global_data, FX_DWORD global_size, uint8_t* dest_buf, FX_DWORD dest_pitch);
-    FX_BOOL             Decode(IFX_FileRead* file_ptr,
+    bool                Decode(IFX_FileRead* file_ptr,
                        FX_DWORD& width, FX_DWORD& height, FX_DWORD& pitch, uint8_t*& dest_buf);
     void*                               CreateJbig2Context();
     FXCODEC_STATUS              StartDecode(void* pJbig2Context, FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
                                     const uint8_t* global_data, FX_DWORD global_size, uint8_t* dest_buf, FX_DWORD dest_pitch, IFX_Pause* pPause);
 
     FXCODEC_STATUS              StartDecode(void* pJbig2Context, IFX_FileRead* file_ptr,
                                     FX_DWORD& width, FX_DWORD& height, FX_DWORD& pitch, uint8_t*& dest_buf, IFX_Pause* pPause);
     FXCODEC_STATUS              ContinueDecode(void* pJbig2Context, IFX_Pause* pPause);
     void                                DestroyJbig2Context(void* pJbig2Context);
     CPDF_Jbig2Interface m_Module;
@@ skipping 11 matching lines @@
     OPJ_SIZE_T     offset;
 };
 
 /* Wrappers for C-style callbacks. */
 OPJ_SIZE_T opj_read_from_memory (void* p_buffer, OPJ_SIZE_T nb_bytes,  void* p_user_data);
 OPJ_SIZE_T opj_write_from_memory (void* p_buffer, OPJ_SIZE_T nb_bytes, void* p_user_data);
 OPJ_OFF_T opj_skip_from_memory (OPJ_OFF_T nb_bytes, void* p_user_data);
 OPJ_BOOL opj_seek_from_memory (OPJ_OFF_T nb_bytes, void* p_user_data);
 
 #endif  // CORE_SRC_FXCODEC_CODEC_CODEC_INT_H_