Get rid of NULLs in core/

core/fpdfdoc/doc_utils.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 <algorithm>
 #include <vector>
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_simple_parser.h"
 #include "core/fpdfdoc/doc_utils.h"
 #include "core/fpdfdoc/include/fpdf_doc.h"
 #include "core/fxge/include/fx_font.h"
 
 namespace {
 
 const int FPDFDOC_UTILS_MAXRECURSION = 32;
 
 CPDF_Object* SearchNumberNode(const CPDF_Dictionary* pNode, int num) {
   CPDF_Array* pLimits = pNode->GetArrayBy("Limits");
   if (pLimits &&
       (num < pLimits->GetIntegerAt(0) || num > pLimits->GetIntegerAt(1))) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Array* pNumbers = pNode->GetArrayBy("Nums");
   if (pNumbers) {
     for (size_t i = 0; i < pNumbers->GetCount() / 2; i++) {
       int index = pNumbers->GetIntegerAt(i * 2);
       if (num == index) {
         return pNumbers->GetDirectObjectAt(i * 2 + 1);
       }
       if (index > num) {
         break;
       }
     }
-    return NULL;
+    return nullptr;
   }
   CPDF_Array* pKids = pNode->GetArrayBy("Kids");
   if (!pKids) {
-    return NULL;
+    return nullptr;
   }
   for (size_t i = 0; i < pKids->GetCount(); i++) {
     CPDF_Dictionary* pKid = pKids->GetDictAt(i);
     if (!pKid) {
       continue;
     }
     CPDF_Object* pFound = SearchNumberNode(pKid, num);
     if (pFound) {
       return pFound;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 }  // namespace
 
 CPDF_Object* CPDF_NumberTree::LookupValue(int num) const {
   return SearchNumberNode(m_pRoot, num);
 }
 
 CFX_WideString GetFullName(CPDF_Dictionary* pFieldDict) {
   CFX_WideString full_name;
@@ skipping 206 matching lines @@
     return;
   }
   if (!pFormDict) {
     pFormDict = new CPDF_Dictionary;
     uint32_t dwObjNum = pDocument->AddIndirectObject(pFormDict);
     CPDF_Dictionary* pRoot = pDocument->GetRoot();
     pRoot->SetAtReference("AcroForm", pDocument, dwObjNum);
   }
   CFX_ByteString csDA;
   if (!pFormDict->KeyExist("DR")) {
-    CPDF_Font* pFont = NULL;
-    CFX_ByteString csBaseName, csDefault;
+    CFX_ByteString csBaseName;
+    CFX_ByteString csDefault;
     uint8_t charSet = CPDF_InterForm::GetNativeCharSet();
-    pFont = CPDF_InterForm::AddStandardFont(pDocument, "Helvetica");
+    CPDF_Font* pFont = CPDF_InterForm::AddStandardFont(pDocument, "Helvetica");
     if (pFont) {
       AddInterFormFont(pFormDict, pDocument, pFont, csBaseName);
       csDefault = csBaseName;
     }
     if (charSet != 0) {
-      CFX_ByteString csFontName = CPDF_InterForm::GetNativeFont(charSet, NULL);
+      CFX_ByteString csFontName =
+          CPDF_InterForm::GetNativeFont(charSet, nullptr);
       if (!pFont || csFontName != "Helvetica") {
         pFont = CPDF_InterForm::AddNativeFont(pDocument);
         if (pFont) {
           csBaseName = "";
           AddInterFormFont(pFormDict, pDocument, pFont, csBaseName);
           csDefault = csBaseName;
         }
       }
     }
     if (pFont) {
@@ skipping 32 matching lines @@
       }
     }
   }
   return dwCount;
 }
 CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
                             CPDF_Document* pDocument,
                             uint32_t index,
                             CFX_ByteString& csNameTag) {
   if (!pFormDict) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
-    return NULL;
+    return nullptr;
   }
   uint32_t dwCount = 0;
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj) {
       continue;
     }
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
     if (pElement->GetStringBy("Type") != "Font")
       continue;
     if (dwCount == index) {
       csNameTag = csKey;
       return pDocument->LoadFont(pElement);
     }
     dwCount++;
   }
-  return NULL;
+  return nullptr;
 }
 CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
                             CPDF_Document* pDocument,
                             CFX_ByteString csNameTag) {
   CFX_ByteString csAlias = PDF_NameDecode(csNameTag);
   if (!pFormDict || csAlias.IsEmpty()) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pElement = pFonts->GetDictBy(csAlias);
   if (!pElement) {
-    return NULL;
+    return nullptr;
   }
   if (pElement->GetStringBy("Type") == "Font") {
     return pDocument->LoadFont(pElement);
   }
-  return NULL;
+  return nullptr;
 }
 CPDF_Font* GetInterFormFont(CPDF_Dictionary* pFormDict,
                             CPDF_Document* pDocument,
                             CFX_ByteString csFontName,
                             CFX_ByteString& csNameTag) {
   if (!pFormDict || csFontName.IsEmpty()) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
-    return NULL;
+    return nullptr;
   }
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj) {
       continue;
     }
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
     if (pElement->GetStringBy("Type") != "Font")
       continue;
 
     CPDF_Font* pFind = pDocument->LoadFont(pElement);
     if (!pFind)
       continue;
 
     CFX_ByteString csBaseFont;
     csBaseFont = pFind->GetBaseFont();
     csBaseFont.Remove(' ');
     if (csBaseFont == csFontName) {
       csNameTag = csKey;
       return pFind;
     }
   }
-  return NULL;
+  return nullptr;
 }
 CPDF_Font* GetNativeInterFormFont(CPDF_Dictionary* pFormDict,
                                   CPDF_Document* pDocument,
                                   uint8_t charSet,
                                   CFX_ByteString& csNameTag) {
   if (!pFormDict) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pDR = pFormDict->GetDictBy("DR");
   if (!pDR) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
-    return NULL;
+    return nullptr;
   }
   for (const auto& it : *pFonts) {
     const CFX_ByteString& csKey = it.first;
     CPDF_Object* pObj = it.second;
     if (!pObj) {
       continue;
     }
     CPDF_Dictionary* pElement = ToDictionary(pObj->GetDirect());
     if (!pElement)
       continue;
     if (pElement->GetStringBy("Type") != "Font")
       continue;
     CPDF_Font* pFind = pDocument->LoadFont(pElement);
     if (!pFind) {
       continue;
     }
     CFX_SubstFont* pSubst = (CFX_SubstFont*)pFind->GetSubstFont();
     if (!pSubst) {
       continue;
     }
     if (pSubst->m_Charset == (int)charSet) {
       csNameTag = csKey;
       return pFind;
     }
   }
-  return NULL;
+  return nullptr;
 }
 CPDF_Font* GetNativeInterFormFont(CPDF_Dictionary* pFormDict,
                                   CPDF_Document* pDocument,
                                   CFX_ByteString& csNameTag) {
   csNameTag = "";
   uint8_t charSet = CPDF_InterForm::GetNativeCharSet();
   CFX_SubstFont* pSubst;
   CPDF_Font* pFont = GetDefaultInterFormFont(pFormDict, pDocument);
   if (pFont) {
     pSubst = (CFX_SubstFont*)pFont->GetSubstFont();
@@ skipping 173 matching lines @@
   CPDF_Dictionary* pFonts = pDR->GetDictBy("Font");
   if (!pFonts) {
     return;
   }
   pFonts->RemoveAt(csNameTag);
 }
 
 CPDF_Font* GetDefaultInterFormFont(CPDF_Dictionary* pFormDict,
                                    CPDF_Document* pDocument) {
   if (!pFormDict) {
-    return NULL;
+    return nullptr;
   }
   CPDF_DefaultAppearance cDA(pFormDict->GetStringBy("DA"));
   CFX_ByteString csFontNameTag;
   FX_FLOAT fFontSize;
   cDA.GetFont(csFontNameTag, fFontSize);
   return GetInterFormFont(pFormDict, pDocument, csFontNameTag);
 }
 
 CPDF_IconFit::ScaleMethod CPDF_IconFit::GetScaleMethod() {
   if (!m_pDict) {
@@ skipping 45 matching lines @@
     if (CPDF_FormControl* pControl = pField->GetControl(i))
       result.push_back(pControl->IsChecked());
   }
   return result;
 }
 
 CPDF_Object* FPDF_GetFieldAttr(CPDF_Dictionary* pFieldDict,
                                const FX_CHAR* name,
                                int nLevel) {
   if (nLevel > FPDFDOC_UTILS_MAXRECURSION) {
-    return NULL;
+    return nullptr;
   }
   if (!pFieldDict) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Object* pAttr = pFieldDict->GetDirectObjectBy(name);
   if (pAttr) {
     return pAttr;
   }
   CPDF_Dictionary* pParent = pFieldDict->GetDictBy("Parent");
   if (!pParent) {
-    return NULL;
+    return nullptr;
   }
   return FPDF_GetFieldAttr(pParent, name, nLevel + 1);
 }