Remove FX_BOOL from core

core/fxge/fx_dib.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_FXGE_FX_DIB_H_
 #define CORE_FXGE_FX_DIB_H_
 
 #include <memory>
@@ skipping 140 matching lines @@
 #define FXARGB_TODIB(argb) (argb)
 #define FXCMYK_TODIB(cmyk)                                    \
   ((uint8_t)((cmyk) >> 24) | ((uint8_t)((cmyk) >> 16)) << 8 | \
    ((uint8_t)((cmyk) >> 8)) << 16 | ((uint8_t)(cmyk) << 24))
 #define FXARGB_TOBGRORDERDIB(argb)                       \
   ((uint8_t)(argb >> 16) | ((uint8_t)(argb >> 8)) << 8 | \
    ((uint8_t)(argb)) << 16 | ((uint8_t)(argb >> 24) << 24))
 #define FXGETFLAG_COLORTYPE(flag) (uint8_t)((flag) >> 8)
 #define FXGETFLAG_ALPHA_FILL(flag) (uint8_t)(flag)
 
-FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
-                      uint8_t* dest_buf,
-                      int dest_pitch,
-                      int width,
-                      int height,
-                      const CFX_DIBSource* pSrcBitmap,
-                      int src_left,
-                      int src_top,
-                      std::unique_ptr<uint32_t, FxFreeDeleter>* pal);
+bool ConvertBuffer(FXDIB_Format dest_format,
+                   uint8_t* dest_buf,
+                   int dest_pitch,
+                   int width,
+                   int height,
+                   const CFX_DIBSource* pSrcBitmap,
+                   int src_left,
+                   int src_top,
+                   std::unique_ptr<uint32_t, FxFreeDeleter>* pal);
 
 class CFX_DIBSource {
  public:
   virtual ~CFX_DIBSource();
 
   virtual uint8_t* GetBuffer() const;
   virtual const uint8_t* GetScanline(int line) const = 0;
-  virtual FX_BOOL SkipToScanline(int line, IFX_Pause* pPause) const;
+  virtual bool SkipToScanline(int line, IFX_Pause* pPause) const;
   virtual void DownSampleScanline(int line,
                                   uint8_t* dest_scan,
                                   int dest_bpp,
                                   int dest_width,
-                                  FX_BOOL bFlipX,
+                                  bool bFlipX,
                                   int clip_left,
                                   int clip_width) const = 0;
 
   int GetWidth() const { return m_Width; }
   int GetHeight() const { return m_Height; }
 
   FXDIB_Format GetFormat() const {
     return (FXDIB_Format)(m_AlphaFlag * 0x100 + m_bpp);
   }
   uint32_t GetPitch() const { return m_Pitch; }
   uint32_t* GetPalette() const { return m_pPalette.get(); }
   int GetBPP() const { return m_bpp; }
 
   // TODO(thestig): Investigate this. Given the possible values of FXDIB_Format,
   // it feels as though this should be implemented as !!(m_AlphaFlag & 1) and
-  // IsOpaqueImage() below should never be able to return TRUE.
+  // IsOpaqueImage() below should never be able to return true.
   bool IsAlphaMask() const { return m_AlphaFlag == 1; }
   bool HasAlpha() const { return !!(m_AlphaFlag & 2); }
   bool IsOpaqueImage() const { return !(m_AlphaFlag & 3); }
   bool IsCmykImage() const { return !!(m_AlphaFlag & 4); }
 
   int GetPaletteSize() const {
     return IsAlphaMask() ? 0 : (m_bpp == 1 ? 2 : (m_bpp == 8 ? 256 : 0));
   }
 
   uint32_t GetPaletteEntry(int index) const;
@@ skipping 13 matching lines @@
                           int dest_height,
                           uint32_t flags = 0,
                           const FX_RECT* pClip = nullptr) const;
   CFX_DIBitmap* TransformTo(const CFX_Matrix* pMatrix,
                             int& left,
                             int& top,
                             uint32_t flags = 0,
                             const FX_RECT* pClip = nullptr) const;
 
   CFX_DIBitmap* GetAlphaMask(const FX_RECT* pClip = nullptr) const;
-  FX_BOOL CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
-                        const FX_RECT* pClip = nullptr);
+  bool CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
+                     const FX_RECT* pClip = nullptr);
 
-  CFX_DIBitmap* SwapXY(FX_BOOL bXFlip,
-                       FX_BOOL bYFlip,
+  CFX_DIBitmap* SwapXY(bool bXFlip,
+                       bool bYFlip,
                        const FX_RECT* pClip = nullptr) const;
 
-  CFX_DIBitmap* FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const;
+  CFX_DIBitmap* FlipImage(bool bXFlip, bool bYFlip) const;
 
   void GetOverlapRect(int& dest_left,
                       int& dest_top,
                       int& width,
                       int& height,
                       int src_width,
                       int src_height,
                       int& src_left,
                       int& src_top,
                       const CFX_ClipRgn* pClipRgn);
 
 #if defined _SKIA_SUPPORT_
   void DebugVerifyBitmapIsPreMultiplied(void* buffer = nullptr) const;
 #endif
 
   CFX_DIBitmap* m_pAlphaMask;
 
  protected:
   CFX_DIBSource();
 
   void BuildPalette();
-  FX_BOOL BuildAlphaMask();
+  bool BuildAlphaMask();
   int FindPalette(uint32_t color) const;
   void GetPalette(uint32_t* pal, int alpha) const;
 
   int m_Width;
   int m_Height;
   int m_bpp;
   uint32_t m_AlphaFlag;
   uint32_t m_Pitch;
   // TODO(weili): Use std::vector for this.
   std::unique_ptr<uint32_t, FxFreeDeleter> m_pPalette;
 };
 
 class CFX_DIBitmap : public CFX_DIBSource {
  public:
   CFX_DIBitmap();
   explicit CFX_DIBitmap(const CFX_DIBitmap& src);
   ~CFX_DIBitmap() override;
 
-  FX_BOOL Create(int width,
-                 int height,
-                 FXDIB_Format format,
-                 uint8_t* pBuffer = nullptr,
-                 int pitch = 0);
+  bool Create(int width,
+              int height,
+              FXDIB_Format format,
+              uint8_t* pBuffer = nullptr,
+              int pitch = 0);
 
-  FX_BOOL Copy(const CFX_DIBSource* pSrc);
+  bool Copy(const CFX_DIBSource* pSrc);
 
   // CFX_DIBSource
   uint8_t* GetBuffer() const override;
   const uint8_t* GetScanline(int line) const override;
   void DownSampleScanline(int line,
                           uint8_t* dest_scan,
                           int dest_bpp,
                           int dest_width,
-                          FX_BOOL bFlipX,
+                          bool bFlipX,
                           int clip_left,
                           int clip_width) const override;
 
   void TakeOver(CFX_DIBitmap* pSrcBitmap);
 
-  FX_BOOL ConvertFormat(FXDIB_Format format);
+  bool ConvertFormat(FXDIB_Format format);
 
   void Clear(uint32_t color);
 
   uint32_t GetPixel(int x, int y) const;
 
   void SetPixel(int x, int y, uint32_t color);
 
-  FX_BOOL LoadChannel(FXDIB_Channel destChannel,
+  bool LoadChannel(FXDIB_Channel destChannel,
+                   const CFX_DIBSource* pSrcBitmap,
+                   FXDIB_Channel srcChannel);
+
+  bool LoadChannel(FXDIB_Channel destChannel, int value);
+
+  bool MultiplyAlpha(int alpha);
+
+  bool MultiplyAlpha(const CFX_DIBSource* pAlphaMask);
+
+  bool TransferBitmap(int dest_left,
+                      int dest_top,
+                      int width,
+                      int height,
                       const CFX_DIBSource* pSrcBitmap,
-                      FXDIB_Channel srcChannel);
+                      int src_left,
+                      int src_top);
 
-  FX_BOOL LoadChannel(FXDIB_Channel destChannel, int value);
-
-  FX_BOOL MultiplyAlpha(int alpha);
-
-  FX_BOOL MultiplyAlpha(const CFX_DIBSource* pAlphaMask);
-
-  FX_BOOL TransferBitmap(int dest_left,
-                         int dest_top,
-                         int width,
-                         int height,
-                         const CFX_DIBSource* pSrcBitmap,
-                         int src_left,
-                         int src_top);
-
-  FX_BOOL CompositeBitmap(int dest_left,
-                          int dest_top,
-                          int width,
-                          int height,
-                          const CFX_DIBSource* pSrcBitmap,
-                          int src_left,
-                          int src_top,
-                          int blend_type = FXDIB_BLEND_NORMAL,
-                          const CFX_ClipRgn* pClipRgn = nullptr,
-                          FX_BOOL bRgbByteOrder = FALSE,
-                          void* pIccTransform = nullptr);
-
-  FX_BOOL TransferMask(int dest_left,
+  bool CompositeBitmap(int dest_left,
                        int dest_top,
                        int width,
                        int height,
-                       const CFX_DIBSource* pMask,
-                       uint32_t color,
+                       const CFX_DIBSource* pSrcBitmap,
                        int src_left,
                        int src_top,
-                       int alpha_flag = 0,
+                       int blend_type = FXDIB_BLEND_NORMAL,
+                       const CFX_ClipRgn* pClipRgn = nullptr,
+                       bool bRgbByteOrder = false,
                        void* pIccTransform = nullptr);
 
-  FX_BOOL CompositeMask(int dest_left,
-                        int dest_top,
-                        int width,
-                        int height,
-                        const CFX_DIBSource* pMask,
-                        uint32_t color,
-                        int src_left,
-                        int src_top,
-                        int blend_type = FXDIB_BLEND_NORMAL,
-                        const CFX_ClipRgn* pClipRgn = nullptr,
-                        FX_BOOL bRgbByteOrder = FALSE,
-                        int alpha_flag = 0,
-                        void* pIccTransform = nullptr);
+  bool TransferMask(int dest_left,
+                    int dest_top,
+                    int width,
+                    int height,
+                    const CFX_DIBSource* pMask,
+                    uint32_t color,
+                    int src_left,
+                    int src_top,
+                    int alpha_flag = 0,
+                    void* pIccTransform = nullptr);
 
-  FX_BOOL CompositeRect(int dest_left,
-                        int dest_top,
-                        int width,
-                        int height,
-                        uint32_t color,
-                        int alpha_flag = 0,
-                        void* pIccTransform = nullptr);
+  bool CompositeMask(int dest_left,
+                     int dest_top,
+                     int width,
+                     int height,
+                     const CFX_DIBSource* pMask,
+                     uint32_t color,
+                     int src_left,
+                     int src_top,
+                     int blend_type = FXDIB_BLEND_NORMAL,
+                     const CFX_ClipRgn* pClipRgn = nullptr,
+                     bool bRgbByteOrder = false,
+                     int alpha_flag = 0,
+                     void* pIccTransform = nullptr);
 
-  FX_BOOL ConvertColorScale(uint32_t forecolor, uint32_t backcolor);
+  bool CompositeRect(int dest_left,
+                     int dest_top,
+                     int width,
+                     int height,
+                     uint32_t color,
+                     int alpha_flag = 0,
+                     void* pIccTransform = nullptr);
+
+  bool ConvertColorScale(uint32_t forecolor, uint32_t backcolor);
 
  protected:
-  FX_BOOL GetGrayData(void* pIccTransform = nullptr);
+  bool GetGrayData(void* pIccTransform = nullptr);
 
   uint8_t* m_pBuffer;
-  FX_BOOL m_bExtBuf;
+  bool m_bExtBuf;
 };
 
 class CFX_DIBExtractor {
  public:
   explicit CFX_DIBExtractor(const CFX_DIBSource* pSrc);
   ~CFX_DIBExtractor();
 
   CFX_DIBitmap* GetBitmap() { return m_pBitmap.get(); }
 
  private:
   std::unique_ptr<CFX_DIBitmap> m_pBitmap;
 };
 
 typedef CFX_SharedCopyOnWrite<CFX_DIBitmap> CFX_DIBitmapRef;
 
 class CFX_FilteredDIB : public CFX_DIBSource {
  public:
   CFX_FilteredDIB();
   ~CFX_FilteredDIB() override;
 
-  void LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc = FALSE);
+  void LoadSrc(const CFX_DIBSource* pSrc, bool bAutoDropSrc = false);
 
   virtual FXDIB_Format GetDestFormat() = 0;
 
   virtual uint32_t* GetDestPalette() = 0;
 
   virtual void TranslateScanline(const uint8_t* src_buf,
                                  std::vector<uint8_t>* dest_buf) const = 0;
 
   virtual void TranslateDownSamples(uint8_t* dest_buf,
                                     const uint8_t* src_buf,
                                     int pixels,
                                     int Bpp) const = 0;
 
  protected:
   // CFX_DIBSource
   const uint8_t* GetScanline(int line) const override;
   void DownSampleScanline(int line,
                           uint8_t* dest_scan,
                           int dest_bpp,
                           int dest_width,
-                          FX_BOOL bFlipX,
+                          bool bFlipX,
                           int clip_left,
                           int clip_width) const override;
 
   const CFX_DIBSource* m_pSrc;
-  FX_BOOL m_bAutoDropSrc;
+  bool m_bAutoDropSrc;
   mutable std::vector<uint8_t> m_Scanline;
 };
 
 class IFX_ScanlineComposer {
  public:
   virtual ~IFX_ScanlineComposer() {}
 
   virtual void ComposeScanline(int line,
                                const uint8_t* scanline,
                                const uint8_t* scan_extra_alpha = nullptr) = 0;
 
-  virtual FX_BOOL SetInfo(int width,
-                          int height,
-                          FXDIB_Format src_format,
-                          uint32_t* pSrcPalette) = 0;
+  virtual bool SetInfo(int width,
+                       int height,
+                       FXDIB_Format src_format,
+                       uint32_t* pSrcPalette) = 0;
 };
 
 class CFX_ScanlineCompositor {
  public:
   CFX_ScanlineCompositor();
 
   ~CFX_ScanlineCompositor();
 
-  FX_BOOL Init(FXDIB_Format dest_format,
-               FXDIB_Format src_format,
-               int32_t width,
-               uint32_t* pSrcPalette,
-               uint32_t mask_color,
-               int blend_type,
-               FX_BOOL bClip,
-               FX_BOOL bRgbByteOrder = FALSE,
-               int alpha_flag = 0,
-               void* pIccTransform = nullptr);
+  bool Init(FXDIB_Format dest_format,
+            FXDIB_Format src_format,
+            int32_t width,
+            uint32_t* pSrcPalette,
+            uint32_t mask_color,
+            int blend_type,
+            bool bClip,
+            bool bRgbByteOrder = false,
+            int alpha_flag = 0,
+            void* pIccTransform = nullptr);
 
   void CompositeRgbBitmapLine(uint8_t* dest_scan,
                               const uint8_t* src_scan,
                               int width,
                               const uint8_t* clip_scan,
                               const uint8_t* src_extra_alpha = nullptr,
                               uint8_t* dst_extra_alpha = nullptr);
 
   void CompositePalBitmapLine(uint8_t* dest_scan,
                               const uint8_t* src_scan,
@@ skipping 19 matching lines @@
  protected:
   int m_Transparency;
   FXDIB_Format m_SrcFormat, m_DestFormat;
   uint32_t* m_pSrcPalette;
 
   int m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue, m_MaskBlack;
   int m_BlendType;
   void* m_pIccTransform;
   uint8_t* m_pCacheScanline;
   int m_CacheSize;
-  FX_BOOL m_bRgbByteOrder;
+  bool m_bRgbByteOrder;
 };
 
 class CFX_BitmapComposer : public IFX_ScanlineComposer {
  public:
   CFX_BitmapComposer();
   ~CFX_BitmapComposer() override;
 
   void Compose(CFX_DIBitmap* pDest,
                const CFX_ClipRgn* pClipRgn,
                int bitmap_alpha,
                uint32_t mask_color,
                FX_RECT& dest_rect,
-               FX_BOOL bVertical,
-               FX_BOOL bFlipX,
-               FX_BOOL bFlipY,
-               FX_BOOL bRgbByteOrder = FALSE,
+               bool bVertical,
+               bool bFlipX,
+               bool bFlipY,
+               bool bRgbByteOrder = false,
                int alpha_flag = 0,
                void* pIccTransform = nullptr,
                int blend_type = FXDIB_BLEND_NORMAL);
 
   // IFX_ScanlineComposer
-  FX_BOOL SetInfo(int width,
-                  int height,
-                  FXDIB_Format src_format,
-                  uint32_t* pSrcPalette) override;
+  bool SetInfo(int width,
+               int height,
+               FXDIB_Format src_format,
+               uint32_t* pSrcPalette) override;
 
   void ComposeScanline(int line,
                        const uint8_t* scanline,
                        const uint8_t* scan_extra_alpha) override;
 
  protected:
   void DoCompose(uint8_t* dest_scan,
                  const uint8_t* src_scan,
                  int dest_width,
                  const uint8_t* clip_scan,
                  const uint8_t* src_extra_alpha = nullptr,
                  uint8_t* dst_extra_alpha = nullptr);
   CFX_DIBitmap* m_pBitmap;
   const CFX_ClipRgn* m_pClipRgn;
   FXDIB_Format m_SrcFormat;
   int m_DestLeft, m_DestTop, m_DestWidth, m_DestHeight, m_BitmapAlpha;
   uint32_t m_MaskColor;
   const CFX_DIBitmap* m_pClipMask;
   CFX_ScanlineCompositor m_Compositor;
-  FX_BOOL m_bVertical, m_bFlipX, m_bFlipY;
+  bool m_bVertical, m_bFlipX, m_bFlipY;
   int m_AlphaFlag;
   void* m_pIccTransform;
-  FX_BOOL m_bRgbByteOrder;
+  bool m_bRgbByteOrder;
   int m_BlendType;
   void ComposeScanlineV(int line,
                         const uint8_t* scanline,
                         const uint8_t* scan_extra_alpha = nullptr);
   uint8_t* m_pScanlineV;
   uint8_t* m_pClipScanV;
   uint8_t* m_pAddClipScan;
   uint8_t* m_pScanlineAlphaV;
 };
 
 class CFX_BitmapStorer : public IFX_ScanlineComposer {
  public:
   CFX_BitmapStorer();
   ~CFX_BitmapStorer() override;
 
   // IFX_ScanlineComposer
   void ComposeScanline(int line,
                        const uint8_t* scanline,
                        const uint8_t* scan_extra_alpha) override;
-  FX_BOOL SetInfo(int width,
-                  int height,
-                  FXDIB_Format src_format,
-                  uint32_t* pSrcPalette) override;
+  bool SetInfo(int width,
+               int height,
+               FXDIB_Format src_format,
+               uint32_t* pSrcPalette) override;
 
   CFX_DIBitmap* GetBitmap() { return m_pBitmap.get(); }
   std::unique_ptr<CFX_DIBitmap> Detach();
   void Replace(std::unique_ptr<CFX_DIBitmap> pBitmap);
 
  private:
   std::unique_ptr<CFX_DIBitmap> m_pBitmap;
 };
 
 class CFX_ImageStretcher {
  public:
   CFX_ImageStretcher(IFX_ScanlineComposer* pDest,
                      const CFX_DIBSource* pSource,
                      int dest_width,
                      int dest_height,
                      const FX_RECT& bitmap_rect,
                      uint32_t flags);
   ~CFX_ImageStretcher();
 
-  FX_BOOL Start();
-  FX_BOOL Continue(IFX_Pause* pPause);
+  bool Start();
+  bool Continue(IFX_Pause* pPause);
 
   const CFX_DIBSource* source() { return m_pSource; }
 
  private:
-  FX_BOOL StartQuickStretch();
-  FX_BOOL StartStretch();
-  FX_BOOL ContinueQuickStretch(IFX_Pause* pPause);
-  FX_BOOL ContinueStretch(IFX_Pause* pPause);
+  bool StartQuickStretch();
+  bool StartStretch();
+  bool ContinueQuickStretch(IFX_Pause* pPause);
+  bool ContinueStretch(IFX_Pause* pPause);
 
   IFX_ScanlineComposer* const m_pDest;
   const CFX_DIBSource* const m_pSource;
   std::unique_ptr<CStretchEngine> m_pStretchEngine;
   std::unique_ptr<uint8_t, FxFreeDeleter> m_pScanline;
   std::unique_ptr<uint8_t, FxFreeDeleter> m_pMaskScanline;
   const uint32_t m_Flags;
-  FX_BOOL m_bFlipX;
-  FX_BOOL m_bFlipY;
+  bool m_bFlipX;
+  bool m_bFlipY;
   int m_DestWidth;
   int m_DestHeight;
   FX_RECT m_ClipRect;
   const FXDIB_Format m_DestFormat;
   const int m_DestBPP;
   int m_LineIndex;
 };
 
 class CFX_ImageTransformer {
  public:
   CFX_ImageTransformer(const CFX_DIBSource* pSrc,
                        const CFX_Matrix* pMatrix,
                        int flags,
                        const FX_RECT* pClip);
   ~CFX_ImageTransformer();
 
-  FX_BOOL Start();
-  FX_BOOL Continue(IFX_Pause* pPause);
+  bool Start();
+  bool Continue(IFX_Pause* pPause);
 
   const FX_RECT& result() const { return m_result; }
   std::unique_ptr<CFX_DIBitmap> DetachBitmap();
 
  private:
   const CFX_DIBSource* const m_pSrc;
   const CFX_Matrix* const m_pMatrix;
   const FX_RECT* const m_pClip;
   FX_RECT m_StretchClip;
   FX_RECT m_result;
   CFX_Matrix m_dest2stretch;
   std::unique_ptr<CFX_ImageStretcher> m_Stretcher;
   CFX_BitmapStorer m_Storer;
   const uint32_t m_Flags;
   int m_Status;
 };
 
 class CFX_ImageRenderer {
  public:
   CFX_ImageRenderer();
   ~CFX_ImageRenderer();
 
-  FX_BOOL Start(CFX_DIBitmap* pDevice,
-                const CFX_ClipRgn* pClipRgn,
-                const CFX_DIBSource* pSource,
-                int bitmap_alpha,
-                uint32_t mask_color,
-                const CFX_Matrix* pMatrix,
-                uint32_t dib_flags,
-                FX_BOOL bRgbByteOrder = FALSE,
-                int alpha_flag = 0,
-                void* pIccTransform = nullptr,
-                int blend_type = FXDIB_BLEND_NORMAL);
+  bool Start(CFX_DIBitmap* pDevice,
+             const CFX_ClipRgn* pClipRgn,
+             const CFX_DIBSource* pSource,
+             int bitmap_alpha,
+             uint32_t mask_color,
+             const CFX_Matrix* pMatrix,
+             uint32_t dib_flags,
+             bool bRgbByteOrder = false,
+             int alpha_flag = 0,
+             void* pIccTransform = nullptr,
+             int blend_type = FXDIB_BLEND_NORMAL);
 
-  FX_BOOL Continue(IFX_Pause* pPause);
+  bool Continue(IFX_Pause* pPause);
 
  protected:
   CFX_DIBitmap* m_pDevice;
   const CFX_ClipRgn* m_pClipRgn;
   int m_BitmapAlpha;
   uint32_t m_MaskColor;
   CFX_Matrix m_Matrix;
   std::unique_ptr<CFX_ImageTransformer> m_pTransformer;
   std::unique_ptr<CFX_ImageStretcher> m_Stretcher;
   CFX_BitmapComposer m_Composer;
   int m_Status;
   FX_RECT m_ClipBox;
   uint32_t m_Flags;
   int m_AlphaFlag;
   void* m_pIccTransform;
-  FX_BOOL m_bRgbByteOrder;
+  bool m_bRgbByteOrder;
   int m_BlendType;
 };
 
 #endif  // CORE_FXGE_FX_DIB_H_