Get rid of NULLs in core/

core/fpdfapi/fpdf_page/cpdf_image.cpp

 // Copyright 2016 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/fpdfapi/fpdf_page/include/cpdf_image.h"
 
 #include "core/fpdfapi/fpdf_page/include/cpdf_page.h"
 #include "core/fpdfapi/fpdf_page/pageint.h"
@@ skipping 40 matching lines @@
   if (m_bInline)
     pImage->SetInlineDict(ToDictionary(m_pInlineDict->Clone(TRUE)));
 
   return pImage;
 }
 
 FX_BOOL CPDF_Image::LoadImageF(CPDF_Stream* pStream, FX_BOOL bInline) {
   m_pStream = pStream;
   if (m_bInline && m_pInlineDict) {
     m_pInlineDict->Release();
-    m_pInlineDict = NULL;
+    m_pInlineDict = nullptr;
   }
   m_bInline = bInline;
   CPDF_Dictionary* pDict = pStream->GetDict();
   if (m_bInline) {
     m_pInlineDict = ToDictionary(pDict->Clone());
   }
   m_pOC = pDict->GetDictBy("OC");
   m_bIsMask =
       !pDict->KeyExist("ColorSpace") || pDict->GetIntegerBy("ImageMask");
   m_bInterpolate = pDict->GetIntegerBy("Interpolate");
   m_Height = pDict->GetIntegerBy("Height");
   m_Width = pDict->GetIntegerBy("Width");
   return TRUE;
 }
 
 CPDF_Dictionary* CPDF_Image::InitJPEG(uint8_t* pData, uint32_t size) {
   int32_t width;
   int32_t height;
   int32_t num_comps;
   int32_t bits;
   FX_BOOL color_trans;
   if (!CPDF_ModuleMgr::Get()->GetJpegModule()->LoadInfo(
           pData, size, width, height, num_comps, bits, color_trans)) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
   pDict->SetAtName("Type", "XObject");
   pDict->SetAtName("Subtype", "Image");
   pDict->SetAtInteger("Width", width);
   pDict->SetAtInteger("Height", height);
-  const FX_CHAR* csname = NULL;
+  const FX_CHAR* csname = nullptr;
   if (num_comps == 1) {
     csname = "DeviceGray";
   } else if (num_comps == 3) {
     csname = "DeviceRGB";
   } else if (num_comps == 4) {
     csname = "DeviceCMYK";
     CPDF_Array* pDecode = new CPDF_Array;
     for (int n = 0; n < 4; n++) {
       pDecode->AddInteger(1);
       pDecode->AddInteger(0);
     }
     pDict->SetAt("Decode", pDecode);
   }
   pDict->SetAtName("ColorSpace", csname);
   pDict->SetAtInteger("BitsPerComponent", bits);
   pDict->SetAtName("Filter", "DCTDecode");
   if (!color_trans) {
     CPDF_Dictionary* pParms = new CPDF_Dictionary;
     pDict->SetAt("DecodeParms", pParms);
     pParms->SetAtInteger("ColorTransform", 0);
   }
   m_bIsMask = FALSE;
   m_Width = width;
   m_Height = height;
   if (!m_pStream) {
-    m_pStream = new CPDF_Stream(NULL, 0, NULL);
+    m_pStream = new CPDF_Stream(nullptr, 0, nullptr);
   }
   return pDict;
 }
 
 void CPDF_Image::SetJpegImage(uint8_t* pData, uint32_t size) {
   CPDF_Dictionary* pDict = InitJPEG(pData, size);
   if (!pDict) {
     return;
   }
   m_pStream->InitStream(pData, size, pDict);
@@ skipping 32 matching lines @@
   }
   uint8_t* src_buf = pBitmap->GetBuffer();
   int32_t src_pitch = pBitmap->GetPitch();
   int32_t bpp = pBitmap->GetBPP();
 
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
   pDict->SetAtName("Type", "XObject");
   pDict->SetAtName("Subtype", "Image");
   pDict->SetAtInteger("Width", BitmapWidth);
   pDict->SetAtInteger("Height", BitmapHeight);
-  uint8_t* dest_buf = NULL;
+  uint8_t* dest_buf = nullptr;
   FX_STRSIZE dest_pitch = 0, dest_size = 0, opType = -1;
   if (bpp == 1) {
     int32_t reset_a = 0, reset_r = 0, reset_g = 0, reset_b = 0;
     int32_t set_a = 0, set_r = 0, set_g = 0, set_b = 0;
     if (!pBitmap->IsAlphaMask()) {
       ArgbDecode(pBitmap->GetPaletteArgb(0), reset_a, reset_r, reset_g,
                  reset_b);
       ArgbDecode(pBitmap->GetPaletteArgb(1), set_a, set_r, set_g, set_b);
     }
     if (set_a == 0 || reset_a == 0) {
@@ skipping 63 matching lines @@
   } else {
     pDict->SetAtName("ColorSpace", "DeviceRGB");
     pDict->SetAtInteger("BitsPerComponent", 8);
     if ((iCompress & 0x03) == PDF_IMAGE_NO_COMPRESS) {
       dest_pitch = BitmapWidth * 3;
       opType = 2;
     } else {
       opType = 0;
     }
   }
-  const CFX_DIBitmap* pMaskBitmap = NULL;
+  const CFX_DIBitmap* pMaskBitmap = nullptr;
   FX_BOOL bDeleteMask = FALSE;
   if (pBitmap->HasAlpha()) {
     pMaskBitmap = pBitmap->GetAlphaMask();
     bDeleteMask = TRUE;
   }
   if (pMaskBitmap) {
     int32_t maskWidth = pMaskBitmap->GetWidth();
     int32_t maskHeight = pMaskBitmap->GetHeight();
-    uint8_t* mask_buf = NULL;
+    uint8_t* mask_buf = nullptr;
     FX_STRSIZE mask_size = 0;
     CPDF_Dictionary* pMaskDict = new CPDF_Dictionary;
     pMaskDict->SetAtName("Type", "XObject");
     pMaskDict->SetAtName("Subtype", "Image");
     pMaskDict->SetAtInteger("Width", maskWidth);
     pMaskDict->SetAtInteger("Height", maskHeight);
     pMaskDict->SetAtName("ColorSpace", "DeviceGray");
     pMaskDict->SetAtInteger("BitsPerComponent", 8);
     if (pMaskBitmap->GetBPP() == 8 &&
         (iCompress & PDF_IMAGE_MASK_LOSSY_COMPRESS) != 0) {
@@ skipping 19 matching lines @@
     if (iCompress & PDF_IMAGE_LOSSLESS_COMPRESS) {
     } else {
       if (pBitmap->GetBPP() == 1) {
       } else if (pBitmap->GetBPP() >= 8 && pBitmap->GetPalette()) {
         CFX_DIBitmap* pNewBitmap = new CFX_DIBitmap();
         pNewBitmap->Copy(pBitmap);
         pNewBitmap->ConvertFormat(FXDIB_Rgb);
         SetImage(pNewBitmap, iCompress);
         if (pDict) {
           pDict->Release();
-          pDict = NULL;
+          pDict = nullptr;
         }
         FX_Free(dest_buf);
-        dest_buf = NULL;
+        dest_buf = nullptr;
         dest_size = 0;
         delete pNewBitmap;
         return;
       }
     }
   } else if (opType == 1) {
     dest_buf = FX_Alloc2D(uint8_t, dest_pitch, BitmapHeight);
     dest_size = dest_pitch * BitmapHeight;  // Safe as checked alloc returned.
 
     uint8_t* pDest = dest_buf;
@@ skipping 18 matching lines @@
         pDest[dest_offset + 2] = (uint8_t)(src_buf[src_offset] * alpha);
         dest_offset += 3;
         src_offset += bpp == 24 ? 3 : 4;
       }
 
       pDest += dest_pitch;
       dest_offset = 0;
     }
   }
   if (!m_pStream) {
-    m_pStream = new CPDF_Stream(NULL, 0, NULL);
+    m_pStream = new CPDF_Stream(nullptr, 0, nullptr);
   }
   m_pStream->InitStream(dest_buf, dest_size, pDict);
   m_bIsMask = pBitmap->IsAlphaMask();
   m_Width = BitmapWidth;
   m_Height = BitmapHeight;
   FX_Free(dest_buf);
 }
 
 void CPDF_Image::ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pBitmap) {
   pPage->GetRenderCache()->ResetBitmap(m_pStream, pBitmap);
@@ skipping 56 matching lines @@
   }
   if (!ret) {
     delete m_pDIBSource;
     m_pDIBSource = nullptr;
     return FALSE;
   }
   m_pMask = pSource->DetachMask();
   m_MatteColor = pSource->GetMatteColor();
   return FALSE;
 }