Get rid of NULLs in core/

core/fxge/dib/fx_dib_convert.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/fxcodec/include/fx_codec.h"
 #include "core/fxge/include/fx_dib.h"
 #include "core/fxge/include/fx_ge.h"
 
@@ skipping 63 matching lines @@
     uint8_t r;
     uint8_t g;
     uint8_t b;
     _ColorDecode(color, r, g, b);
     dest_pal[row] = ((uint32_t)r << 16) | ((uint32_t)g << 8) | b | 0xff000000;
     aLut[lut_offset] = row;
   }
 }
 
 CFX_Palette::CFX_Palette() {
-  m_pPalette = NULL;
-  m_cLut = NULL;
-  m_aLut = NULL;
+  m_pPalette = nullptr;
+  m_cLut = nullptr;
+  m_aLut = nullptr;
   m_lut = 0;
 }
 CFX_Palette::~CFX_Palette() {
   FX_Free(m_pPalette);
   FX_Free(m_cLut);
   FX_Free(m_aLut);
   m_lut = 0;
 }
 FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap) {
   if (!pBitmap) {
     return FALSE;
   }
   FX_Free(m_pPalette);
   m_pPalette = FX_Alloc(uint32_t, 256);
   int bpp = pBitmap->GetBPP() / 8;
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   FX_Free(m_cLut);
-  m_cLut = NULL;
+  m_cLut = nullptr;
   FX_Free(m_aLut);
-  m_aLut = NULL;
+  m_aLut = nullptr;
   m_cLut = FX_Alloc(uint32_t, 4096);
   m_aLut = FX_Alloc(uint32_t, 4096);
   int row, col;
   m_lut = 0;
   for (row = 0; row < height; row++) {
     uint8_t* scan_line = (uint8_t*)pBitmap->GetScanline(row);
     for (col = 0; col < width; col++) {
       uint8_t* src_port = scan_line + col * bpp;
       uint32_t b = src_port[0] & 0xf0;
       uint32_t g = src_port[1] & 0xf0;
@@ skipping 697 matching lines @@
                       int width,
                       int height,
                       const CFX_DIBSource* pSrcBitmap,
                       int src_left,
                       int src_top,
                       uint32_t*& d_pal,
                       void* pIccTransform) {
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
-    pIccTransform = NULL;
+    pIccTransform = nullptr;
   }
   switch (dest_format) {
     case FXDIB_Invalid:
     case FXDIB_1bppCmyk:
     case FXDIB_1bppMask:
     case FXDIB_1bppRgb:
       ASSERT(FALSE);
       return FALSE;
     case FXDIB_8bppMask: {
       if ((src_format & 0xff) == 1) {
@@ skipping 116 matching lines @@
 }
 CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format,
                                           const FX_RECT* pClip,
                                           void* pIccTransform) const {
   if (dest_format == GetFormat() && !pIccTransform) {
     return Clone(pClip);
   }
   if (pClip) {
     CFX_DIBitmap* pClone = Clone(pClip);
     if (!pClone) {
-      return NULL;
+      return nullptr;
     }
     if (!pClone->ConvertFormat(dest_format, pIccTransform)) {
       delete pClone;
-      return NULL;
+      return nullptr;
     }
     return pClone;
   }
   CFX_DIBitmap* pClone = new CFX_DIBitmap;
   if (!pClone->Create(m_Width, m_Height, dest_format)) {
     delete pClone;
-    return NULL;
+    return nullptr;
   }
   FX_BOOL ret = TRUE;
-  CFX_DIBitmap* pSrcAlpha = NULL;
+  CFX_DIBitmap* pSrcAlpha = nullptr;
   if (HasAlpha()) {
     pSrcAlpha = (GetFormat() == FXDIB_Argb) ? GetAlphaMask() : m_pAlphaMask;
     if (!pSrcAlpha) {
       delete pClone;
-      return NULL;
+      return nullptr;
     }
   }
   if (dest_format & 0x0200) {
     if (dest_format == FXDIB_Argb) {
       ret = pSrcAlpha ? pClone->LoadChannel(FXDIB_Alpha, pSrcAlpha, FXDIB_Alpha)
                       : pClone->LoadChannel(FXDIB_Alpha, 0xff);
     } else {
       ret = pClone->CopyAlphaMask(pSrcAlpha);
     }
   }
   if (pSrcAlpha && pSrcAlpha != m_pAlphaMask) {
     delete pSrcAlpha;
-    pSrcAlpha = NULL;
+    pSrcAlpha = nullptr;
   }
   if (!ret) {
     delete pClone;
-    return NULL;
+    return nullptr;
   }
-  uint32_t* pal_8bpp = NULL;
+  uint32_t* pal_8bpp = nullptr;
   ret = ConvertBuffer(dest_format, pClone->GetBuffer(), pClone->GetPitch(),
                       m_Width, m_Height, this, 0, 0, pal_8bpp, pIccTransform);
   if (!ret) {
     FX_Free(pal_8bpp);
     delete pClone;
-    return NULL;
+    return nullptr;
   }
   if (pal_8bpp) {
     pClone->CopyPalette(pal_8bpp);
     FX_Free(pal_8bpp);
-    pal_8bpp = NULL;
+    pal_8bpp = nullptr;
   }
   return pClone;
 }
 FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format,
                                     void* pIccTransform) {
   FXDIB_Format src_format = GetFormat();
   if (dest_format == src_format && !pIccTransform) {
     return TRUE;
   }
   if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb &&
@@ skipping 12 matching lines @@
       }
     }
     return TRUE;
   }
   int dest_bpp = dest_format & 0xff;
   int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
   uint8_t* dest_buf = FX_TryAlloc(uint8_t, dest_pitch * m_Height + 4);
   if (!dest_buf) {
     return FALSE;
   }
-  CFX_DIBitmap* pAlphaMask = NULL;
+  CFX_DIBitmap* pAlphaMask = nullptr;
   if (dest_format == FXDIB_Argb) {
     FXSYS_memset(dest_buf, 0xff, dest_pitch * m_Height + 4);
     if (m_pAlphaMask) {
       for (int row = 0; row < m_Height; row++) {
         uint8_t* pDstScanline = dest_buf + row * dest_pitch + 3;
         const uint8_t* pSrcScanline = m_pAlphaMask->GetScanline(row);
         for (int col = 0; col < m_Width; col++) {
           *pDstScanline = *pSrcScanline++;
           pDstScanline += 4;
         }
       }
     }
   } else if (dest_format & 0x0200) {
     if (src_format == FXDIB_Argb) {
       pAlphaMask = GetAlphaMask();
       if (!pAlphaMask) {
         FX_Free(dest_buf);
         return FALSE;
       }
     } else {
       if (!m_pAlphaMask) {
         if (!BuildAlphaMask()) {
           FX_Free(dest_buf);
           return FALSE;
         }
         pAlphaMask = m_pAlphaMask;
-        m_pAlphaMask = NULL;
+        m_pAlphaMask = nullptr;
       } else {
         pAlphaMask = m_pAlphaMask;
       }
     }
   }
   FX_BOOL ret = FALSE;
-  uint32_t* pal_8bpp = NULL;
+  uint32_t* pal_8bpp = nullptr;
   ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height,
                       this, 0, 0, pal_8bpp, pIccTransform);
   if (!ret) {
     FX_Free(pal_8bpp);
     if (pAlphaMask != m_pAlphaMask) {
       delete pAlphaMask;
     }
     FX_Free(dest_buf);
     return FALSE;
   }
   if (m_pAlphaMask && pAlphaMask != m_pAlphaMask) {
     delete m_pAlphaMask;
   }
   m_pAlphaMask = pAlphaMask;
   FX_Free(m_pPalette);
   m_pPalette = pal_8bpp;
   if (!m_bExtBuf) {
     FX_Free(m_pBuffer);
   }
   m_bExtBuf = FALSE;
   m_pBuffer = dest_buf;
   m_bpp = (uint8_t)dest_format;
   m_AlphaFlag = (uint8_t)(dest_format >> 8);
   m_Pitch = dest_pitch;
   return TRUE;
 }