Get rid of NULLs in core/

core/fpdfapi/fpdf_render/fpdf_render.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/fpdfapi/fpdf_render/render_int.h"
 
 #include "core/fpdfapi/fpdf_font/cpdf_type3char.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type3font.h"
@@ skipping 43 matching lines @@
     if (bRelease || value->use_count() < 2) {
       delete value->get();
       delete value;
       m_TransferFuncMap.erase(curr_it);
     }
   }
 
   if (m_pFontCache) {
     if (bRelease) {
       delete m_pFontCache;
-      m_pFontCache = NULL;
+      m_pFontCache = nullptr;
     } else {
       m_pFontCache->FreeCache(FALSE);
     }
   }
 }
 
 CPDF_Type3Cache* CPDF_DocRenderData::GetCachedType3(CPDF_Type3Font* pFont) {
   CPDF_CountedObject<CPDF_Type3Cache>* pCache;
   auto it = m_Type3FaceMap.find(pFont);
   if (it == m_Type3FaceMap.end()) {
@@ skipping 10 matching lines @@
   auto it = m_Type3FaceMap.find(pFont);
   if (it != m_Type3FaceMap.end())
     it->second->RemoveRef();
 }
 
 CPDF_RenderOptions::CPDF_RenderOptions()
     : m_ColorMode(RENDER_COLOR_NORMAL),
       m_Flags(RENDER_CLEARTYPE),
       m_Interpolation(0),
       m_AddFlags(0),
-      m_pOCContext(NULL),
+      m_pOCContext(nullptr),
       m_dwLimitCacheSize(1024 * 1024 * 100),
       m_HalftoneLimit(-1) {}
 FX_ARGB CPDF_RenderOptions::TranslateColor(FX_ARGB argb) const {
   if (m_ColorMode == RENDER_COLOR_NORMAL) {
     return argb;
   }
   if (m_ColorMode == RENDER_COLOR_ALPHA) {
     return argb;
   }
   int a, r, g, b;
@@ skipping 211 matching lines @@
   }
   rect.Intersect(rtClip);
   return rect.IsEmpty();
 }
 
 void CPDF_RenderStatus::ProcessObjectNoClip(const CPDF_PageObject* pObj,
                                             const CFX_Matrix* pObj2Device) {
   FX_BOOL bRet = FALSE;
   switch (pObj->GetType()) {
     case CPDF_PageObject::TEXT:
-      bRet = ProcessText(pObj->AsText(), pObj2Device, NULL);
+      bRet = ProcessText(pObj->AsText(), pObj2Device, nullptr);
       break;
     case CPDF_PageObject::PATH:
       bRet = ProcessPath(pObj->AsPath(), pObj2Device);
       break;
     case CPDF_PageObject::IMAGE:
       bRet = ProcessImage(pObj->AsImage(), pObj2Device);
       break;
     case CPDF_PageObject::SHADING:
       ProcessShading(pObj->AsShading(), pObj2Device);
       return;
@@ skipping 39 matching lines @@
       m_pDevice->GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
     res = 0;
   }
   CPDF_ScaledRenderBuffer buffer;
   if (!buffer.Initialize(m_pContext, m_pDevice, rect, pObj, &m_Options, res)) {
     return;
   }
   CFX_Matrix matrix = *pObj2Device;
   matrix.Concat(*buffer.GetMatrix());
   GetScaledMatrix(matrix);
-  CPDF_Dictionary* pFormResource = NULL;
+  CPDF_Dictionary* pFormResource = nullptr;
   if (pObj->IsForm()) {
     const CPDF_FormObject* pFormObj = pObj->AsForm();
     if (pFormObj->m_pForm && pFormObj->m_pForm->m_pFormDict) {
       pFormResource = pFormObj->m_pForm->m_pFormDict->GetDictBy("Resources");
     }
   }
   CPDF_RenderStatus status;
-  status.Initialize(m_pContext, buffer.GetDevice(), buffer.GetMatrix(), NULL,
-                    NULL, NULL, &m_Options, m_Transparency, m_bDropObjects,
-                    pFormResource);
+  status.Initialize(m_pContext, buffer.GetDevice(), buffer.GetMatrix(), nullptr,
+                    nullptr, nullptr, &m_Options, m_Transparency,
+                    m_bDropObjects, pFormResource);
   status.RenderSingleObject(pObj, &matrix);
   buffer.OutputToDevice();
 }
 FX_BOOL CPDF_RenderStatus::ProcessForm(const CPDF_FormObject* pFormObj,
                                        const CFX_Matrix* pObj2Device) {
   CPDF_Dictionary* pOC = pFormObj->m_pForm->m_pFormDict->GetDictBy("OC");
   if (pOC && m_Options.m_pOCContext &&
       !m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
     return TRUE;
   }
   CFX_Matrix matrix = pFormObj->m_FormMatrix;
   matrix.Concat(*pObj2Device);
-  CPDF_Dictionary* pResources = NULL;
+  CPDF_Dictionary* pResources = nullptr;
   if (pFormObj->m_pForm && pFormObj->m_pForm->m_pFormDict) {
     pResources = pFormObj->m_pForm->m_pFormDict->GetDictBy("Resources");
   }
   CPDF_RenderStatus status;
-  status.Initialize(m_pContext, m_pDevice, NULL, m_pStopObj, this, pFormObj,
+  status.Initialize(m_pContext, m_pDevice, nullptr, m_pStopObj, this, pFormObj,
                     &m_Options, m_Transparency, m_bDropObjects, pResources,
                     FALSE);
   status.m_curBlend = m_curBlend;
   m_pDevice->SaveState();
   status.RenderObjectList(pFormObj->m_pForm, &matrix);
   m_bStopped = status.m_bStopped;
   m_pDevice->RestoreState(false);
   return TRUE;
 }
 FX_BOOL IsAvailableMatrix(const CFX_Matrix& matrix) {
@@ skipping 236 matching lines @@
 }
 FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
                                                const CFX_Matrix* pObj2Device) {
   const CPDF_GeneralStateData* pGeneralState = pPageObj->m_GeneralState;
   int blend_type =
       pGeneralState ? pGeneralState->m_BlendType : FXDIB_BLEND_NORMAL;
   if (blend_type == FXDIB_BLEND_UNSUPPORTED) {
     return TRUE;
   }
   CPDF_Dictionary* pSMaskDict =
-      pGeneralState ? ToDictionary(pGeneralState->m_pSoftMask) : NULL;
+      pGeneralState ? ToDictionary(pGeneralState->m_pSoftMask) : nullptr;
   if (pSMaskDict) {
     if (pPageObj->IsImage() &&
         pPageObj->AsImage()->m_pImage->GetDict()->KeyExist("SMask")) {
-      pSMaskDict = NULL;
+      pSMaskDict = nullptr;
     }
   }
-  CPDF_Dictionary* pFormResource = NULL;
+  CPDF_Dictionary* pFormResource = nullptr;
   FX_FLOAT group_alpha = 1.0f;
   int Transparency = m_Transparency;
   FX_BOOL bGroupTransparent = FALSE;
   if (pPageObj->IsForm()) {
     const CPDF_FormObject* pFormObj = pPageObj->AsForm();
     const CPDF_GeneralStateData* pStateData =
         pFormObj->m_GeneralState.GetObject();
     if (pStateData) {
       group_alpha = pStateData->m_FillAlpha;
     }
     Transparency = pFormObj->m_pForm->m_Transparency;
     bGroupTransparent = !!(Transparency & PDFTRANS_ISOLATED);
     if (pFormObj->m_pForm->m_pFormDict) {
       pFormResource = pFormObj->m_pForm->m_pFormDict->GetDictBy("Resources");
     }
   }
   FX_BOOL bTextClip = FALSE;
   if (pPageObj->m_ClipPath.NotNull() && pPageObj->m_ClipPath.GetTextCount() &&
       m_pDevice->GetDeviceClass() == FXDC_DISPLAY &&
       !(m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_SOFT_CLIP)) {
     bTextClip = TRUE;
   }
   if ((m_Options.m_Flags & RENDER_OVERPRINT) && pPageObj->IsImage() &&
       pGeneralState && pGeneralState->m_FillOP && pGeneralState->m_StrokeOP) {
-    CPDF_Document* pDocument = NULL;
-    CPDF_Page* pPage = NULL;
+    CPDF_Document* pDocument = nullptr;
+    CPDF_Page* pPage = nullptr;
     if (m_pContext->GetPageCache()) {
       pPage = m_pContext->GetPageCache()->GetPage();
       pDocument = pPage->m_pDocument;
     } else {
       pDocument = pPageObj->AsImage()->m_pImage->GetDocument();
     }
-    CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : NULL;
+    CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : nullptr;
     CPDF_Object* pCSObj = pPageObj->AsImage()
                               ->m_pImage->GetStream()
                               ->GetDict()
                               ->GetDirectObjectBy("ColorSpace");
     CPDF_ColorSpace* pColorSpace =
         pDocument->LoadColorSpace(pCSObj, pPageResources);
     if (pColorSpace) {
       int format = pColorSpace->GetFamily();
       if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION ||
           format == PDFCS_DEVICEN) {
@@ skipping 66 matching lines @@
       CFX_Matrix text_matrix;
       textobj->GetTextMatrix(&text_matrix);
       CPDF_TextRenderer::DrawTextPath(
           &text_device, textobj->m_nChars, textobj->m_pCharCodes,
           textobj->m_pCharPos, textobj->m_TextState.GetFont(),
           textobj->m_TextState.GetFontSize(), &text_matrix, &new_matrix,
           textobj->m_GraphState, (FX_ARGB)-1, 0, nullptr, 0);
     }
   }
   CPDF_RenderStatus bitmap_render;
-  bitmap_render.Initialize(m_pContext, &bitmap_device, NULL, m_pStopObj, NULL,
-                           NULL, &m_Options, 0, m_bDropObjects, pFormResource,
-                           TRUE);
+  bitmap_render.Initialize(m_pContext, &bitmap_device, nullptr, m_pStopObj,
+                           nullptr, nullptr, &m_Options, 0, m_bDropObjects,
+                           pFormResource, TRUE);
   bitmap_render.ProcessObjectNoClip(pPageObj, &new_matrix);
   m_bStopped = bitmap_render.m_bStopped;
   if (pSMaskDict) {
     CFX_Matrix smask_matrix;
     FXSYS_memcpy(&smask_matrix, pGeneralState->m_SMaskMatrix,
                  sizeof smask_matrix);
     smask_matrix.Concat(*pObj2Device);
     std::unique_ptr<CFX_DIBSource> pSMaskSource(
         LoadSMask(pSMaskDict, &rect, &smask_matrix));
     if (pSMaskSource)
@@ skipping 72 matching lines @@
   device.Attach(pBuffer, false, nullptr, false);
 
   FX_RECT rect(0, 0, device.GetWidth(), device.GetHeight());
   device.FillRect(&rect, 0xffffffff);
   Render(&device, pObj, pOptions, pFinalMatrix);
 }
 CPDF_GraphicStates* CPDF_RenderStatus::CloneObjStates(
     const CPDF_GraphicStates* pSrcStates,
     FX_BOOL bStroke) {
   if (!pSrcStates) {
-    return NULL;
+    return nullptr;
   }
   CPDF_GraphicStates* pStates = new CPDF_GraphicStates;
   pStates->CopyStates(*pSrcStates);
   CPDF_Color* pObjColor = bStroke ? pSrcStates->m_ColorState.GetStrokeColor()
                                   : pSrcStates->m_ColorState.GetFillColor();
   if (!pObjColor->IsNull()) {
     CPDF_ColorStateData* pColorData = pStates->m_ColorState.GetModify();
     pColorData->m_FillRGB =
         bStroke ? pSrcStates->m_ColorState.GetObject()->m_StrokeRGB
                 : pSrcStates->m_ColorState.GetObject()->m_FillRGB;
@@ skipping 23 matching lines @@
   pLayer->m_pObjectHolder = pObjectHolder;
   if (pObject2Device) {
     pLayer->m_Matrix = *pObject2Device;
   } else {
     pLayer->m_Matrix.SetIdentity();
   }
 }
 void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice,
                                 const CPDF_RenderOptions* pOptions,
                                 const CFX_Matrix* pLastMatrix) {
-  Render(pDevice, NULL, pOptions, pLastMatrix);
+  Render(pDevice, nullptr, pOptions, pLastMatrix);
 }
 void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice,
                                 const CPDF_PageObject* pStopObj,
                                 const CPDF_RenderOptions* pOptions,
                                 const CFX_Matrix* pLastMatrix) {
   int count = m_Layers.GetSize();
   for (int j = 0; j < count; j++) {
     pDevice->SaveState();
     Layer* pLayer = m_Layers.GetDataPtr(j);
     if (pLastMatrix) {
       CFX_Matrix FinalMatrix = pLayer->m_Matrix;
       FinalMatrix.Concat(*pLastMatrix);
       CPDF_RenderStatus status;
-      status.Initialize(this, pDevice, pLastMatrix, pStopObj, NULL, NULL,
+      status.Initialize(this, pDevice, pLastMatrix, pStopObj, nullptr, nullptr,
                         pOptions, pLayer->m_pObjectHolder->m_Transparency,
-                        FALSE, NULL);
+                        FALSE, nullptr);
       status.RenderObjectList(pLayer->m_pObjectHolder, &FinalMatrix);
       if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
         m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
       }
       if (status.m_bStopped) {
         pDevice->RestoreState(false);
         break;
       }
     } else {
       CPDF_RenderStatus status;
-      status.Initialize(this, pDevice, NULL, pStopObj, NULL, NULL, pOptions,
-                        pLayer->m_pObjectHolder->m_Transparency, FALSE, NULL);
+      status.Initialize(this, pDevice, nullptr, pStopObj, nullptr, nullptr,
+                        pOptions, pLayer->m_pObjectHolder->m_Transparency,
+                        FALSE, nullptr);
       status.RenderObjectList(pLayer->m_pObjectHolder, &pLayer->m_Matrix);
       if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
         m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
       }
       if (status.m_bStopped) {
         pDevice->RestoreState(false);
         break;
       }
     }
     pDevice->RestoreState(false);
@@ skipping 30 matching lines @@
     if (!m_pCurrentLayer) {
       if (m_LayerIndex >= m_pContext->CountLayers()) {
         m_Status = Done;
         return;
       }
       m_pCurrentLayer = m_pContext->GetLayer(m_LayerIndex);
       m_LastObjectRendered =
           m_pCurrentLayer->m_pObjectHolder->GetPageObjectList()->end();
       m_pRenderStatus.reset(new CPDF_RenderStatus());
       m_pRenderStatus->Initialize(
-          m_pContext, m_pDevice, NULL, NULL, NULL, NULL, m_pOptions,
-          m_pCurrentLayer->m_pObjectHolder->m_Transparency, FALSE, NULL);
+          m_pContext, m_pDevice, nullptr, nullptr, nullptr, nullptr, m_pOptions,
+          m_pCurrentLayer->m_pObjectHolder->m_Transparency, FALSE, nullptr);
       m_pDevice->SaveState();
       m_ClipRect = CFX_FloatRect(m_pDevice->GetClipBox());
       CFX_Matrix device2object;
       device2object.SetReverse(m_pCurrentLayer->m_Matrix);
       device2object.TransformRect(m_ClipRect);
     }
     CPDF_PageObjectList::iterator iter;
     CPDF_PageObjectList::iterator iterEnd =
         m_pCurrentLayer->m_pObjectHolder->GetPageObjectList()->end();
     if (m_LastObjectRendered != iterEnd) {
@@ skipping 168 matching lines @@
     if (m_Matrix.a == 1.0f && m_Matrix.d == 1.0f) {
       m_pDevice->SetDIBits(m_pBitmap.get(), m_Rect.left, m_Rect.top);
     } else {
       m_pDevice->StretchDIBits(m_pBitmap.get(), m_Rect.left, m_Rect.top,
                                m_Rect.Width(), m_Rect.Height());
     }
   } else {
     CFX_DIBitmap buffer;
     m_pDevice->CreateCompatibleBitmap(&buffer, m_pBitmap->GetWidth(),
                                       m_pBitmap->GetHeight());
-    m_pContext->GetBackground(&buffer, m_pObject, NULL, &m_Matrix);
+    m_pContext->GetBackground(&buffer, m_pObject, nullptr, &m_Matrix);
     buffer.CompositeBitmap(0, 0, buffer.GetWidth(), buffer.GetHeight(),
                            m_pBitmap.get(), 0, 0);
     m_pDevice->StretchDIBits(&buffer, m_Rect.left, m_Rect.top, m_Rect.Width(),
                              m_Rect.Height());
   }
 }
 
 CPDF_ScaledRenderBuffer::CPDF_ScaledRenderBuffer() {}
 
 CPDF_ScaledRenderBuffer::~CPDF_ScaledRenderBuffer() {}
@@ skipping 53 matching lines @@
   m_pContext->GetBackground(m_pBitmapDevice->GetBitmap(), m_pObject, pOptions,
                             &m_Matrix);
   return TRUE;
 }
 void CPDF_ScaledRenderBuffer::OutputToDevice() {
   if (m_pBitmapDevice) {
     m_pDevice->StretchDIBits(m_pBitmapDevice->GetBitmap(), m_Rect.left,
                              m_Rect.top, m_Rect.Width(), m_Rect.Height());
   }
 }