Get rid of NULLs in core/

core/fpdfapi/fpdf_page/fpdf_page_parser.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_page/pageint.h"
 
 #include <vector>
 
@@ skipping 64 matching lines @@
   CFX_ByteStringC replacement;
 };
 
 class CPDF_StreamParserAutoClearer {
  public:
   CPDF_StreamParserAutoClearer(CPDF_StreamParser** scoped_variable,
                                CPDF_StreamParser* new_parser)
       : scoped_variable_(scoped_variable) {
     *scoped_variable_ = new_parser;
   }
-  ~CPDF_StreamParserAutoClearer() { *scoped_variable_ = NULL; }
+  ~CPDF_StreamParserAutoClearer() { *scoped_variable_ = nullptr; }
 
  private:
   CPDF_StreamParser** scoped_variable_;
 };
 
 CFX_ByteStringC PDF_FindFullName(const PDF_AbbrPair* table,
                                  size_t count,
                                  const CFX_ByteStringC& abbr) {
   auto it = std::find_if(
       table, table + count,
@@ skipping 218 matching lines @@
     if (index == PARAM_BUF_SIZE) {
       index = 0;
     }
   }
   m_ParamStartPos = 0;
   m_ParamCount = 0;
 }
 
 CPDF_Object* CPDF_StreamContentParser::GetObject(uint32_t index) {
   if (index >= m_ParamCount) {
-    return NULL;
+    return nullptr;
   }
   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
   if (real_index >= PARAM_BUF_SIZE) {
     real_index -= PARAM_BUF_SIZE;
   }
   ContentParam& param = m_ParamBuf[real_index];
   if (param.m_Type == ContentParam::NUMBER) {
     CPDF_Number* pNumber = param.m_Number.m_bInteger
                                ? new CPDF_Number(param.m_Number.m_Integer)
                                : new CPDF_Number(param.m_Number.m_Float);
 
     param.m_Type = ContentParam::OBJECT;
     param.m_pObject = pNumber;
     return pNumber;
   }
   if (param.m_Type == ContentParam::NAME) {
     CPDF_Name* pName = new CPDF_Name(
         CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len));
     param.m_Type = ContentParam::OBJECT;
     param.m_pObject = pName;
     return pName;
   }
   if (param.m_Type == ContentParam::OBJECT) {
     return param.m_pObject;
   }
   ASSERT(FALSE);
-  return NULL;
+  return nullptr;
 }
 
 CFX_ByteString CPDF_StreamContentParser::GetString(uint32_t index) {
   if (index >= m_ParamCount) {
     return CFX_ByteString();
   }
   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
   if (real_index >= PARAM_BUF_SIZE) {
     real_index -= PARAM_BUF_SIZE;
   }
@@ skipping 243 matching lines @@
         m_pSyntax->ReadNextObject(false, 0));
     if (!key.IsEmpty()) {
       uint32_t dwObjNum = pObj ? pObj->GetObjNum() : 0;
       if (dwObjNum)
         pDict->SetAtReference(key, m_pDocument, dwObjNum);
       else
         pDict->SetAt(key, pObj.release());
     }
   }
   PDF_ReplaceAbbr(pDict);
-  CPDF_Object* pCSObj = NULL;
+  CPDF_Object* pCSObj = nullptr;
   if (pDict->KeyExist("ColorSpace")) {
     pCSObj = pDict->GetDirectObjectBy("ColorSpace");
     if (pCSObj->IsName()) {
       CFX_ByteString name = pCSObj->GetString();
       if (name != "DeviceRGB" && name != "DeviceGray" && name != "DeviceCMYK") {
         pCSObj = FindResourceObj("ColorSpace", name);
         if (pCSObj && !pCSObj->GetObjNum()) {
           pCSObj = pCSObj->Clone();
           pDict->SetAt("ColorSpace", pCSObj);
         }
       }
     }
   }
   CPDF_Stream* pStream =
       m_pSyntax->ReadInlineStream(m_pDocument, pDict, pCSObj);
   while (1) {
     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
     if (type == CPDF_StreamParser::EndOfData) {
       break;
     }
     if (type != CPDF_StreamParser::Keyword) {
       continue;
     }
     if (m_pSyntax->GetWordSize() == 2 && m_pSyntax->GetWordBuf()[0] == 'E' &&
         m_pSyntax->GetWordBuf()[1] == 'I') {
       break;
     }
   }
   pDict->SetAtName("Subtype", "Image");
-  CPDF_ImageObject* pImgObj = AddImage(pStream, NULL, TRUE);
+  CPDF_ImageObject* pImgObj = AddImage(pStream, nullptr, TRUE);
   if (!pImgObj) {
     if (pStream) {
       pStream->Release();
     } else {
       pDict->Release();
     }
   }
 }
 
 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
   CFX_ByteString tag = GetString(0);
-  m_CurContentMark.GetModify()->AddMark(tag, NULL, FALSE);
+  m_CurContentMark.GetModify()->AddMark(tag, nullptr, FALSE);
 }
 
 void CPDF_StreamContentParser::Handle_BeginText() {
   m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
   OnChangeTextMatrix();
   m_pCurStates->m_TextX = 0;
   m_pCurStates->m_TextY = 0;
   m_pCurStates->m_TextLineX = 0;
   m_pCurStates->m_TextLineY = 0;
 }
@@ skipping 63 matching lines @@
   if (!pXObject) {
     m_bResourceMissing = TRUE;
     return;
   }
 
   CFX_ByteString type;
   if (pXObject->GetDict())
     type = pXObject->GetDict()->GetStringBy("Subtype");
 
   if (type == "Image") {
-    CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
+    CPDF_ImageObject* pObj = AddImage(pXObject, nullptr, FALSE);
     m_LastImageName = name;
     m_pLastImage = pObj->m_pImage;
     if (!m_pObjectHolder->HasImageMask())
       m_pObjectHolder->SetHasImageMask(m_pLastImage->IsMask());
   } else if (type == "Form") {
     AddForm(pXObject);
   }
 }
 
 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
@@ skipping 14 matching lines @@
   }
   pFormObj->CalcBoundingBox();
   SetGraphicStates(pFormObj.get(), TRUE, TRUE, TRUE);
   m_pObjectHolder->GetPageObjectList()->push_back(std::move(pFormObj));
 }
 
 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream,
                                                      CPDF_Image* pImage,
                                                      FX_BOOL bInline) {
   if (!pStream && !pImage) {
-    return NULL;
+    return nullptr;
   }
   CFX_Matrix ImageMatrix;
   ImageMatrix.Copy(m_pCurStates->m_CTM);
   ImageMatrix.Concat(m_mtContentToUser);
 
   std::unique_ptr<CPDF_ImageObject> pImageObj(new CPDF_ImageObject);
   if (pImage) {
     pImageObj->m_pImage =
         m_pDocument->GetPageData()->GetImage(pImage->GetStream());
   } else if (pStream->GetObjNum()) {
@@ skipping 216 matching lines @@
 
 void CPDF_StreamContentParser::Handle_SetColor_Fill() {
   FX_FLOAT values[4];
   int nargs = m_ParamCount;
   if (nargs > 4) {
     nargs = 4;
   }
   for (int i = 0; i < nargs; i++) {
     values[i] = GetNumber(nargs - i - 1);
   }
-  m_pCurStates->m_ColorState.SetFillColor(NULL, values, nargs);
+  m_pCurStates->m_ColorState.SetFillColor(nullptr, values, nargs);
 }
 
 void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
   FX_FLOAT values[4];
   int nargs = m_ParamCount;
   if (nargs > 4) {
     nargs = 4;
   }
   for (int i = 0; i < nargs; i++) {
     values[i] = GetNumber(nargs - i - 1);
   }
-  m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nargs);
+  m_pCurStates->m_ColorState.SetStrokeColor(nullptr, values, nargs);
 }
 
 void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
   CPDF_Object* pLastParam = GetObject(0);
   if (!pLastParam) {
     return;
   }
   uint32_t nargs = m_ParamCount;
   uint32_t nvalues = nargs;
   if (pLastParam->IsName())
     nvalues--;
-  FX_FLOAT* values = NULL;
+  FX_FLOAT* values = nullptr;
   if (nvalues) {
     values = FX_Alloc(FX_FLOAT, nvalues);
     for (uint32_t i = 0; i < nvalues; i++) {
       values[i] = GetNumber(nargs - i - 1);
     }
   }
   if (nvalues != nargs) {
     CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
     if (pPattern) {
       m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
     }
   } else {
-    m_pCurStates->m_ColorState.SetFillColor(NULL, values, nvalues);
+    m_pCurStates->m_ColorState.SetFillColor(nullptr, values, nvalues);
   }
   FX_Free(values);
 }
 
 void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
   CPDF_Object* pLastParam = GetObject(0);
   if (!pLastParam) {
     return;
   }
   int nargs = m_ParamCount;
   int nvalues = nargs;
   if (pLastParam->IsName())
     nvalues--;
 
-  FX_FLOAT* values = NULL;
+  FX_FLOAT* values = nullptr;
   if (nvalues) {
     values = FX_Alloc(FX_FLOAT, nvalues);
     for (int i = 0; i < nvalues; i++) {
       values[i] = GetNumber(nargs - i - 1);
     }
   }
   if (nvalues != nargs) {
     CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
     if (pPattern) {
       m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
     }
   } else {
-    m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nvalues);
+    m_pCurStates->m_ColorState.SetStrokeColor(nullptr, values, nvalues);
   }
   FX_Free(values);
 }
 
 void CPDF_StreamContentParser::Handle_ShadeFill() {
   CPDF_Pattern* pPattern = FindPattern(GetString(0), true);
   if (!pPattern)
     return;
 
   CPDF_ShadingPattern* pShading = pPattern->AsShadingPattern();
@@ skipping 44 matching lines @@
   CPDF_Font* pFont = FindFont(GetString(1));
   if (pFont) {
     m_pCurStates->m_TextState.SetFont(pFont);
   }
 }
 
 CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
     const CFX_ByteString& type,
     const CFX_ByteString& name) {
   if (!m_pResources) {
-    return NULL;
+    return nullptr;
   }
   if (m_pResources == m_pPageResources) {
     CPDF_Dictionary* pList = m_pResources->GetDictBy(type);
     if (!pList) {
-      return NULL;
+      return nullptr;
     }
     CPDF_Object* pRes = pList->GetDirectObjectBy(name);
     return pRes;
   }
   CPDF_Dictionary* pList = m_pResources->GetDictBy(type);
   if (!pList) {
     if (!m_pPageResources) {
-      return NULL;
+      return nullptr;
     }
     CPDF_Dictionary* pList = m_pPageResources->GetDictBy(type);
     if (!pList) {
-      return NULL;
+      return nullptr;
     }
     CPDF_Object* pRes = pList->GetDirectObjectBy(name);
     return pRes;
   }
   CPDF_Object* pRes = pList->GetDirectObjectBy(name);
   return pRes;
 }
 
 CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name) {
   CPDF_Dictionary* pFontDict = ToDictionary(FindResourceObj("Font", name));
@@ skipping 26 matching lines @@
       if (name == "DeviceRGB") {
         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
       }
       return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
     }
     return m_pDocument->LoadColorSpace(pDefObj);
   }
   CPDF_Object* pCSObj = FindResourceObj("ColorSpace", name);
   if (!pCSObj) {
     m_bResourceMissing = TRUE;
-    return NULL;
+    return nullptr;
   }
   return m_pDocument->LoadColorSpace(pCSObj);
 }
 
 CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
                                                     bool bShading) {
   CPDF_Object* pPattern =
       FindResourceObj(bShading ? "Shading" : "Pattern", name);
   if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
     m_bResourceMissing = TRUE;
@@ skipping 74 matching lines @@
           1000;
     }
   }
 }
 
 void CPDF_StreamContentParser::Handle_ShowText() {
   CFX_ByteString str = GetString(0);
   if (str.IsEmpty()) {
     return;
   }
-  AddTextObject(&str, 0, NULL, 1);
+  AddTextObject(&str, 0, nullptr, 1);
 }
 
 void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
   CPDF_Array* pArray = ToArray(GetObject(0));
   if (!pArray)
     return;
 
   size_t n = pArray->GetCount();
   size_t nsegs = 0;
   for (size_t i = 0; i < n; i++) {
@@ skipping 383 matching lines @@
         } else {
           PDF_ReplaceAbbr(pElement);
         }
       }
       break;
     }
     default:
       break;
   }
 }