Get rid of NULLs in core/

core/fxge/dib/fx_dib_main.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/fxge/include/fx_dib.h"
 
 #include <limits.h>
 
@@ skipping 30 matching lines @@
 uint32_t ArgbEncode(int a, FX_COLORREF rgb) {
   return FXARGB_MAKE(a, FXSYS_GetRValue(rgb), FXSYS_GetGValue(rgb),
                      FXSYS_GetBValue(rgb));
 }
 
 CFX_DIBSource::CFX_DIBSource() {
   m_bpp = 0;
   m_AlphaFlag = 0;
   m_Width = m_Height = 0;
   m_Pitch = 0;
-  m_pPalette = NULL;
-  m_pAlphaMask = NULL;
+  m_pPalette = nullptr;
+  m_pAlphaMask = nullptr;
 }
 
 CFX_DIBSource::~CFX_DIBSource() {
   FX_Free(m_pPalette);
   delete m_pAlphaMask;
 }
 
 uint8_t* CFX_DIBSource::GetBuffer() const {
-  return NULL;
+  return nullptr;
 }
 
 FX_BOOL CFX_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const {
   return FALSE;
 }
 
 CFX_DIBitmap::CFX_DIBitmap() {
   m_bExtBuf = FALSE;
-  m_pBuffer = NULL;
-  m_pPalette = NULL;
+  m_pBuffer = nullptr;
+  m_pPalette = nullptr;
 }
 
 #define _MAX_OOM_LIMIT_ 12000000
 FX_BOOL CFX_DIBitmap::Create(int width,
                              int height,
                              FXDIB_Format format,
                              uint8_t* pBuffer,
                              int pitch) {
-  m_pBuffer = NULL;
+  m_pBuffer = nullptr;
   m_bpp = (uint8_t)format;
   m_AlphaFlag = (uint8_t)(format >> 8);
   m_Width = m_Height = m_Pitch = 0;
   if (width <= 0 || height <= 0 || pitch < 0) {
     return FALSE;
   }
   if ((INT_MAX - 31) / width < (format & 0xff)) {
     return FALSE;
   }
   if (!pitch) {
@@ skipping 19 matching lines @@
   }
   m_Width = width;
   m_Height = height;
   m_Pitch = pitch;
   if (HasAlpha() && format != FXDIB_Argb) {
     FX_BOOL ret = TRUE;
     ret = BuildAlphaMask();
     if (!ret) {
       if (!m_bExtBuf) {
         FX_Free(m_pBuffer);
-        m_pBuffer = NULL;
+        m_pBuffer = nullptr;
         m_Width = m_Height = m_Pitch = 0;
         return FALSE;
       }
     }
   }
   return TRUE;
 }
 
 FX_BOOL CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc) {
   if (m_pBuffer) {
@@ skipping 43 matching lines @@
   m_Width = pSrcBitmap->m_Width;
   m_Height = pSrcBitmap->m_Height;
   m_Pitch = pSrcBitmap->m_Pitch;
 }
 
 CFX_DIBitmap* CFX_DIBSource::Clone(const FX_RECT* pClip) const {
   FX_RECT rect(0, 0, m_Width, m_Height);
   if (pClip) {
     rect.Intersect(*pClip);
     if (rect.IsEmpty()) {
-      return NULL;
+      return nullptr;
     }
   }
   CFX_DIBitmap* pNewBitmap = new CFX_DIBitmap;
   if (!pNewBitmap->Create(rect.Width(), rect.Height(), GetFormat())) {
     delete pNewBitmap;
-    return NULL;
+    return nullptr;
   }
   pNewBitmap->CopyPalette(m_pPalette);
   pNewBitmap->CopyAlphaMask(m_pAlphaMask, pClip);
   if (GetBPP() == 1 && rect.left % 8 != 0) {
     int left_shift = rect.left % 32;
     int right_shift = 32 - left_shift;
     int dword_count = pNewBitmap->m_Pitch / 4;
     for (int row = rect.top; row < rect.bottom; row++) {
       uint32_t* src_scan = (uint32_t*)GetScanline(row) + rect.left / 32;
       uint32_t* dest_scan = (uint32_t*)pNewBitmap->GetScanline(row - rect.top);
@@ skipping 41 matching lines @@
     }
   }
 }
 FX_BOOL CFX_DIBSource::BuildAlphaMask() {
   if (m_pAlphaMask) {
     return TRUE;
   }
   m_pAlphaMask = new CFX_DIBitmap;
   if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
     delete m_pAlphaMask;
-    m_pAlphaMask = NULL;
+    m_pAlphaMask = nullptr;
     return FALSE;
   }
   FXSYS_memset(m_pAlphaMask->GetBuffer(), 0xff,
                m_pAlphaMask->GetHeight() * m_pAlphaMask->GetPitch());
   return TRUE;
 }
 uint32_t CFX_DIBSource::GetPaletteEntry(int index) const {
   ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
   if (m_pPalette) {
     return m_pPalette[index];
@@ skipping 140 matching lines @@
                                      int width,
                                      int height,
                                      const CFX_DIBSource* pSrcBitmap,
                                      int src_left,
                                      int src_top,
                                      void* pIccTransform) {
   if (!m_pBuffer) {
     return FALSE;
   }
   GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(),
-                 pSrcBitmap->GetHeight(), src_left, src_top, NULL);
+                 pSrcBitmap->GetHeight(), src_left, src_top, nullptr);
   if (width == 0 || height == 0) {
     return TRUE;
   }
   FXDIB_Format dest_format = GetFormat();
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
   if (dest_format == src_format && !pIccTransform) {
     if (GetBPP() == 1) {
       for (int row = 0; row < height; row++) {
         uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
@@ skipping 20 matching lines @@
     }
   } else {
     if (m_pPalette) {
       return FALSE;
     }
     if (m_bpp == 8) {
       dest_format = FXDIB_8bppMask;
     }
     uint8_t* dest_buf =
         m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
-    uint32_t* d_plt = NULL;
+    uint32_t* d_plt = nullptr;
     if (!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height,
                        pSrcBitmap, src_left, src_top, d_plt, pIccTransform)) {
       return FALSE;
     }
   }
   return TRUE;
 }
 FX_BOOL CFX_DIBitmap::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,
                                    void* pIccTransform) {
   if (!m_pBuffer) {
     return FALSE;
   }
   ASSERT(HasAlpha() && (m_bpp >= 24));
   ASSERT(pMask->IsAlphaMask());
   if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
     return FALSE;
   }
   GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(),
-                 pMask->GetHeight(), src_left, src_top, NULL);
+                 pMask->GetHeight(), src_left, src_top, nullptr);
   if (width == 0 || height == 0) {
     return TRUE;
   }
   int src_bpp = pMask->GetBPP();
   int alpha;
   uint32_t dst_color;
   if (alpha_flag >> 8) {
     alpha = alpha_flag & 0xff;
     dst_color = FXCMYK_TODIB(color);
   } else {
@@ skipping 72 matching lines @@
           *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
         }
       }
     }
   }
   return TRUE;
 }
 void CFX_DIBSource::CopyPalette(const uint32_t* pSrc, uint32_t size) {
   if (!pSrc || GetBPP() > 8) {
     FX_Free(m_pPalette);
-    m_pPalette = NULL;
+    m_pPalette = nullptr;
   } else {
     uint32_t pal_size = 1 << GetBPP();
     if (!m_pPalette) {
       m_pPalette = FX_Alloc(uint32_t, pal_size);
     }
     if (pal_size > size) {
       pal_size = size;
     }
     FXSYS_memcpy(m_pPalette, pSrc, pal_size * sizeof(uint32_t));
   }
@@ skipping 16 matching lines @@
       pal[i] = (i * 0x10101) | (alpha << 24);
     }
   }
 }
 CFX_DIBitmap* CFX_DIBSource::GetAlphaMask(const FX_RECT* pClip) const {
   ASSERT(GetFormat() == FXDIB_Argb);
   FX_RECT rect(0, 0, m_Width, m_Height);
   if (pClip) {
     rect.Intersect(*pClip);
     if (rect.IsEmpty()) {
-      return NULL;
+      return nullptr;
     }
   }
   CFX_DIBitmap* pMask = new CFX_DIBitmap;
   if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_8bppMask)) {
     delete pMask;
-    return NULL;
+    return nullptr;
   }
   for (int row = rect.top; row < rect.bottom; row++) {
     const uint8_t* src_scan = GetScanline(row) + rect.left * 4 + 3;
     uint8_t* dest_scan = (uint8_t*)pMask->GetScanline(row - rect.top);
     for (int col = rect.left; col < rect.right; col++) {
       *dest_scan++ = *src_scan;
       src_scan += 4;
     }
   }
   return pMask;
@@ skipping 125 matching lines @@
         pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
         if (!pAlphaMask) {
           if (pSrcClone != pSrcBitmap) {
             delete pSrcClone;
           }
           return FALSE;
         }
       }
     }
     if (pSrcClone != pSrcBitmap) {
-      pSrcClone->m_pAlphaMask = NULL;
+      pSrcClone->m_pAlphaMask = nullptr;
       delete pSrcClone;
     }
     pSrcClone = pAlphaMask;
     srcOffset = 0;
   } else if (pSrcClone->GetWidth() != m_Width ||
              pSrcClone->GetHeight() != m_Height) {
     CFX_DIBitmap* pSrcMatched = pSrcClone->StretchTo(m_Width, m_Height);
     if (pSrcClone != pSrcBitmap) {
       delete pSrcClone;
     }
@@ skipping 600 matching lines @@
       }
     }
   }
   return TRUE;
 }
 
 CFX_DIBitmap* CFX_DIBSource::FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const {
   CFX_DIBitmap* pFlipped = new CFX_DIBitmap;
   if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
     delete pFlipped;
-    return NULL;
+    return nullptr;
   }
   pFlipped->CopyPalette(m_pPalette);
   uint8_t* pDestBuffer = pFlipped->GetBuffer();
   int Bpp = m_bpp / 8;
   for (int row = 0; row < m_Height; row++) {
     const uint8_t* src_scan = GetScanline(row);
     uint8_t* dest_scan =
         pDestBuffer + m_Pitch * (bYFlip ? (m_Height - row - 1) : row);
     if (!bXFlip) {
       FXSYS_memcpy(dest_scan, src_scan, m_Pitch);
@@ skipping 47 matching lines @@
       for (int col = 0; col < m_Width; col++) {
         *dest_scan = *src_scan;
         dest_scan--;
         src_scan++;
       }
     }
   }
   return pFlipped;
 }
 CFX_DIBExtractor::CFX_DIBExtractor(const CFX_DIBSource* pSrc) {
-  m_pBitmap = NULL;
+  m_pBitmap = nullptr;
   if (pSrc->GetBuffer()) {
     m_pBitmap = new CFX_DIBitmap;
     if (!m_pBitmap->Create(pSrc->GetWidth(), pSrc->GetHeight(),
                            pSrc->GetFormat(), pSrc->GetBuffer())) {
       delete m_pBitmap;
-      m_pBitmap = NULL;
+      m_pBitmap = nullptr;
       return;
     }
     m_pBitmap->CopyPalette(pSrc->GetPalette());
     m_pBitmap->CopyAlphaMask(pSrc->m_pAlphaMask);
   } else {
     m_pBitmap = pSrc->Clone();
   }
 }
 CFX_DIBExtractor::~CFX_DIBExtractor() {
   delete m_pBitmap;
 }
 CFX_FilteredDIB::CFX_FilteredDIB() {
-  m_pScanline = NULL;
-  m_pSrc = NULL;
+  m_pScanline = nullptr;
+  m_pSrc = nullptr;
 }
 CFX_FilteredDIB::~CFX_FilteredDIB() {
   if (m_bAutoDropSrc) {
     delete m_pSrc;
   }
   FX_Free(m_pScanline);
 }
 void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc) {
   m_pSrc = pSrc;
   m_bAutoDropSrc = bAutoDropSrc;
@@ skipping 16 matching lines @@
                                          int dest_width,
                                          FX_BOOL bFlipX,
                                          int clip_left,
                                          int clip_width) const {
   m_pSrc->DownSampleScanline(line, dest_scan, dest_bpp, dest_width, bFlipX,
                              clip_left, clip_width);
   TranslateDownSamples(dest_scan, dest_scan, clip_width, dest_bpp);
 }
 CFX_ImageRenderer::CFX_ImageRenderer() {
   m_Status = 0;
-  m_pTransformer = NULL;
+  m_pTransformer = nullptr;
   m_bRgbByteOrder = FALSE;
   m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_ImageRenderer::~CFX_ImageRenderer() {
   delete m_pTransformer;
 }
 
 FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice,
                                  const CFX_ClipRgn* pClipRgn,
                                  const CFX_DIBSource* pSource,
@@ skipping 153 matching lines @@
                                   uint32_t* pSrcPalette) {
   m_pBitmap.reset(new CFX_DIBitmap);
   if (!m_pBitmap->Create(width, height, src_format)) {
     m_pBitmap.reset();
     return FALSE;
   }
   if (pSrcPalette)
     m_pBitmap->CopyPalette(pSrcPalette);
   return TRUE;
 }