Get rid of NULLs in core/

core/fxge/include/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_INCLUDE_FX_DIB_H_
 #define CORE_FXGE_INCLUDE_FX_DIB_H_
 
 #include <memory>
@@ skipping 186 matching lines @@
   uint32_t GetPaletteEntry(int index) const;
 
   void SetPaletteEntry(int index, uint32_t color);
   uint32_t GetPaletteArgb(int index) const { return GetPaletteEntry(index); }
   void SetPaletteArgb(int index, uint32_t color) {
     SetPaletteEntry(index, color);
   }
 
   void CopyPalette(const uint32_t* pSrcPal, uint32_t size = 256);
 
-  CFX_DIBitmap* Clone(const FX_RECT* pClip = NULL) const;
+  CFX_DIBitmap* Clone(const FX_RECT* pClip = nullptr) const;
   CFX_DIBitmap* CloneConvert(FXDIB_Format format,
-                             const FX_RECT* pClip = NULL,
-                             void* pIccTransform = NULL) const;
+                             const FX_RECT* pClip = nullptr,
+                             void* pIccTransform = nullptr) const;
 
   CFX_DIBitmap* StretchTo(int dest_width,
                           int dest_height,
                           uint32_t flags = 0,
-                          const FX_RECT* pClip = NULL) const;
+                          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 = NULL) const;
+                            const FX_RECT* pClip = nullptr) const;
 
-  CFX_DIBitmap* GetAlphaMask(const FX_RECT* pClip = NULL) const;
+  CFX_DIBitmap* GetAlphaMask(const FX_RECT* pClip = nullptr) const;
   FX_BOOL CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
-                        const FX_RECT* pClip = NULL);
+                        const FX_RECT* pClip = nullptr);
 
   CFX_DIBitmap* SwapXY(FX_BOOL bXFlip,
                        FX_BOOL bYFlip,
-                       const FX_RECT* pClip = NULL) const;
+                       const FX_RECT* pClip = nullptr) const;
 
   CFX_DIBitmap* FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const;
 
   void GetOverlapRect(int& dest_left,
                       int& dest_top,
                       int& width,
                       int& height,
                       int src_width,
                       int src_height,
                       int& src_left,
@@ skipping 20 matching lines @@
 
 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 = NULL,
+                 uint8_t* pBuffer = nullptr,
                  int pitch = 0);
 
   FX_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,
                           int clip_left,
                           int clip_width) const override;
 
   void TakeOver(CFX_DIBitmap* pSrcBitmap);
 
-  FX_BOOL ConvertFormat(FXDIB_Format format, void* pIccTransform = NULL);
+  FX_BOOL ConvertFormat(FXDIB_Format format, void* pIccTransform = nullptr);
 
   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,
                       const CFX_DIBSource* pSrcBitmap,
                       FXDIB_Channel srcChannel);
 
   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,
-                         void* pIccTransform = NULL);
+                         void* pIccTransform = nullptr);
 
   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 = NULL,
+                          const CFX_ClipRgn* pClipRgn = nullptr,
                           FX_BOOL bRgbByteOrder = FALSE,
-                          void* pIccTransform = NULL);
+                          void* pIccTransform = nullptr);
 
   FX_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 = NULL);
+                       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 = NULL,
+                        const CFX_ClipRgn* pClipRgn = nullptr,
                         FX_BOOL bRgbByteOrder = FALSE,
                         int alpha_flag = 0,
-                        void* pIccTransform = NULL);
+                        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 = NULL);
+                        void* pIccTransform = nullptr);
 
   FX_BOOL ConvertColorScale(uint32_t forecolor, uint32_t backcolor);
 
  protected:
-  FX_BOOL GetGrayData(void* pIccTransform = NULL);
+  FX_BOOL GetGrayData(void* pIccTransform = nullptr);
 
   uint8_t* m_pBuffer;
   FX_BOOL m_bExtBuf;
 };
 
 class CFX_DIBExtractor {
  public:
   CFX_DIBExtractor(const CFX_DIBSource* pSrc);
 
   ~CFX_DIBExtractor();
@@ skipping 41 matching lines @@
 
   uint8_t* m_pScanline;
 };
 
 class IFX_ScanlineComposer {
  public:
   virtual ~IFX_ScanlineComposer() {}
 
   virtual void ComposeScanline(int line,
                                const uint8_t* scanline,
-                               const uint8_t* scan_extra_alpha = NULL) = 0;
+                               const uint8_t* scan_extra_alpha = nullptr) = 0;
 
   virtual FX_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 = NULL);
+               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 = NULL,
-                              uint8_t* dst_extra_alpha = NULL);
+                              const uint8_t* src_extra_alpha = nullptr,
+                              uint8_t* dst_extra_alpha = nullptr);
 
   void CompositePalBitmapLine(uint8_t* dest_scan,
                               const uint8_t* src_scan,
                               int src_left,
                               int width,
                               const uint8_t* clip_scan,
-                              const uint8_t* src_extra_alpha = NULL,
-                              uint8_t* dst_extra_alpha = NULL);
+                              const uint8_t* src_extra_alpha = nullptr,
+                              uint8_t* dst_extra_alpha = nullptr);
 
   void CompositeByteMaskLine(uint8_t* dest_scan,
                              const uint8_t* src_scan,
                              int width,
                              const uint8_t* clip_scan,
-                             uint8_t* dst_extra_alpha = NULL);
+                             uint8_t* dst_extra_alpha = nullptr);
 
   void CompositeBitMaskLine(uint8_t* dest_scan,
                             const uint8_t* src_scan,
                             int src_left,
                             int width,
                             const uint8_t* clip_scan,
-                            uint8_t* dst_extra_alpha = NULL);
+                            uint8_t* dst_extra_alpha = nullptr);
 
  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;
 };
 
 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,
                int alpha_flag = 0,
-               void* pIccTransform = NULL,
+               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;
 
   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 = NULL,
-                 uint8_t* dst_extra_alpha = NULL);
+                 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;
   int m_AlphaFlag;
   void* m_pIccTransform;
   FX_BOOL m_bRgbByteOrder;
   int m_BlendType;
   void ComposeScanlineV(int line,
                         const uint8_t* scanline,
-                        const uint8_t* scan_extra_alpha = NULL);
+                        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;
@@ skipping 86 matching lines @@
 
   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 = NULL,
+                void* pIccTransform = nullptr,
                 int blend_type = FXDIB_BLEND_NORMAL);
 
   FX_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;
   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;
   int m_BlendType;
 };
 
 #endif  // CORE_FXGE_INCLUDE_FX_DIB_H_