Get rid of NULLs in core/

core/fpdfdoc/doc_form.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 <vector>
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_fontencoding.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_page.h"
@@ skipping 79 matching lines @@
         count += children.GetAt(i)->CountFields(nLevel + 1);
       }
       return count;
     }
     CPDF_FormField* GetField(int* fields_to_go) {
       if (field_ptr) {
         if (*fields_to_go == 0) {
           return field_ptr;
         }
         --*fields_to_go;
-        return NULL;
+        return nullptr;
       }
       for (int i = 0; i < children.GetSize(); i++) {
         if (CPDF_FormField* pField = children.GetAt(i)->GetField(fields_to_go))
           return pField;
       }
-      return NULL;
+      return nullptr;
     }
     CPDF_FormField* GetField(int index) {
       int fields_to_go = index;
       return GetField(&fields_to_go);
     }
   };
   CFieldTree();
   ~CFieldTree();
   void SetField(const CFX_WideString& full_name, CPDF_FormField* field_ptr);
   CPDF_FormField* GetField(const CFX_WideString& full_name);
   CPDF_FormField* RemoveField(const CFX_WideString& full_name);
   void RemoveAll();
   _Node* FindNode(const CFX_WideString& full_name);
   _Node* AddChild(_Node* pParent,
                   const CFX_WideString& short_name,
                   CPDF_FormField* field_ptr);
   void RemoveNode(_Node* pNode, int nLevel = 0);
   _Node* _Lookup(_Node* pParent, const CFX_WideString& short_name);
   _Node m_Root;
 };
 CFieldTree::CFieldTree() {
-  m_Root.parent = NULL;
-  m_Root.field_ptr = NULL;
+  m_Root.parent = nullptr;
+  m_Root.field_ptr = nullptr;
 }
 CFieldTree::~CFieldTree() {
   RemoveAll();
 }
 CFieldTree::_Node* CFieldTree::AddChild(_Node* pParent,
                                         const CFX_WideString& short_name,
                                         CPDF_FormField* field_ptr) {
   if (!pParent) {
-    return NULL;
+    return nullptr;
   }
   _Node* pNode = new _Node;
   pNode->parent = pParent;
   pNode->short_name = short_name;
   pNode->field_ptr = field_ptr;
   pParent->children.Add(pNode);
   return pNode;
 }
 void CFieldTree::RemoveNode(_Node* pNode, int nLevel) {
   if (!pNode) {
     return;
   }
   if (nLevel <= nMaxRecursion) {
     for (int i = 0; i < pNode->children.GetSize(); i++) {
       RemoveNode(pNode->children[i], nLevel + 1);
     }
   }
   delete pNode;
 }
 CFieldTree::_Node* CFieldTree::_Lookup(_Node* pParent,
                                        const CFX_WideString& short_name) {
   if (!pParent) {
-    return NULL;
+    return nullptr;
   }
   for (int i = 0; i < pParent->children.GetSize(); i++) {
     _Node* pNode = pParent->children[i];
     if (pNode->short_name.GetLength() == short_name.GetLength() &&
         FXSYS_memcmp(pNode->short_name.c_str(), short_name.c_str(),
                      short_name.GetLength() * sizeof(FX_WCHAR)) == 0) {
       return pNode;
     }
   }
-  return NULL;
+  return nullptr;
 }
 void CFieldTree::RemoveAll() {
   for (int i = 0; i < m_Root.children.GetSize(); i++) {
     RemoveNode(m_Root.children[i]);
   }
 }
 void CFieldTree::SetField(const CFX_WideString& full_name,
                           CPDF_FormField* field_ptr) {
   if (full_name == L"") {
     return;
   }
   CFieldNameExtractor name_extractor(full_name);
   const FX_WCHAR* pName;
   FX_STRSIZE nLength;
   name_extractor.GetNext(pName, nLength);
-  _Node *pNode = &m_Root, *pLast = NULL;
+  _Node *pNode = &m_Root, *pLast = nullptr;
   while (nLength > 0) {
     pLast = pNode;
     CFX_WideString name = CFX_WideString(pName, nLength);
     pNode = _Lookup(pLast, name);
     if (!pNode) {
-      pNode = AddChild(pLast, name, NULL);
+      pNode = AddChild(pLast, name, nullptr);
     }
     name_extractor.GetNext(pName, nLength);
   }
   if (pNode != &m_Root) {
     pNode->field_ptr = field_ptr;
   }
 }
 CPDF_FormField* CFieldTree::GetField(const CFX_WideString& full_name) {
   if (full_name == L"") {
-    return NULL;
+    return nullptr;
   }
   CFieldNameExtractor name_extractor(full_name);
   const FX_WCHAR* pName;
   FX_STRSIZE nLength;
   name_extractor.GetNext(pName, nLength);
-  _Node *pNode = &m_Root, *pLast = NULL;
+  _Node *pNode = &m_Root, *pLast = nullptr;
   while (nLength > 0 && pNode) {
     pLast = pNode;
     CFX_WideString name = CFX_WideString(pName, nLength);
     pNode = _Lookup(pLast, name);
     name_extractor.GetNext(pName, nLength);
   }
-  return pNode ? pNode->field_ptr : NULL;
+  return pNode ? pNode->field_ptr : nullptr;
 }
 CPDF_FormField* CFieldTree::RemoveField(const CFX_WideString& full_name) {
   if (full_name == L"") {
-    return NULL;
+    return nullptr;
   }
   CFieldNameExtractor name_extractor(full_name);
   const FX_WCHAR* pName;
   FX_STRSIZE nLength;
   name_extractor.GetNext(pName, nLength);
-  _Node *pNode = &m_Root, *pLast = NULL;
+  _Node *pNode = &m_Root, *pLast = nullptr;

[Tom Sepez, 2016/06/02 20:09:48]

nit: one per line while we're at it.

[Lei Zhang, 2016/06/07 07:33:23]

Done.

   while (nLength > 0 && pNode) {
     pLast = pNode;
     CFX_WideString name = CFX_WideString(pName, nLength);
     pNode = _Lookup(pLast, name);
     name_extractor.GetNext(pName, nLength);
   }
   if (pNode && pNode != &m_Root) {
     for (int i = 0; i < pLast->children.GetSize(); i++) {
       if (pNode == pLast->children[i]) {
         pLast->children.RemoveAt(i);
         break;
       }
     }
     CPDF_FormField* pField = pNode->field_ptr;
     RemoveNode(pNode);
     return pField;
   }
-  return NULL;
+  return nullptr;
 }
 CFieldTree::_Node* CFieldTree::FindNode(const CFX_WideString& full_name) {
   if (full_name == L"") {
-    return NULL;
+    return nullptr;
   }
   CFieldNameExtractor name_extractor(full_name);
   const FX_WCHAR* pName;
   FX_STRSIZE nLength;
   name_extractor.GetNext(pName, nLength);
-  _Node *pNode = &m_Root, *pLast = NULL;
+  _Node *pNode = &m_Root, *pLast = nullptr;
   while (nLength > 0 && pNode) {
     pLast = pNode;
     CFX_WideString name = CFX_WideString(pName, nLength);
     pNode = _Lookup(pLast, name);
     name_extractor.GetNext(pName, nLength);
   }
   return pNode;
 }
 
 CPDF_InterForm::CPDF_InterForm(CPDF_Document* pDocument)
@@ skipping 103 matching lines @@
     return 1;
   }
   LPDF_FONTDATA pData = (LPDF_FONTDATA)lParam;
   memcpy(&pData->lf, &lpelfe->elfLogFont, sizeof(LOGFONTA));
   pData->bFind = TRUE;
   return 0;
 }
 static FX_BOOL RetrieveSpecificFont(LOGFONTA& lf) {
   PDF_FONTDATA fd;
   memset(&fd, 0, sizeof(PDF_FONTDATA));
-  HDC hDC = ::GetDC(NULL);
+  HDC hDC = ::GetDC(nullptr);
   EnumFontFamiliesExA(hDC, &lf, (FONTENUMPROCA)EnumFontFamExProc, (LPARAM)&fd,
                       0);
-  ::ReleaseDC(NULL, hDC);
+  ::ReleaseDC(nullptr, hDC);
   if (fd.bFind) {
     memcpy(&lf, &fd.lf, sizeof(LOGFONTA));
   }
   return fd.bFind;
 }
 static FX_BOOL RetrieveSpecificFont(uint8_t charSet,
                                     uint8_t pitchAndFamily,
                                     LPCSTR pcsFontName,
                                     LOGFONTA& lf) {
   memset(&lf, 0, sizeof(LOGFONTA));
@@ skipping 41 matching lines @@
   }
   if (!bRet) {
     bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE,
                                 "Arial Unicode MS", lf);
   }
   if (!bRet) {
     bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE,
                                 "Microsoft Sans Serif", lf);
   }
   if (!bRet) {
-    bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, NULL, lf);
+    bRet =
+        RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, nullptr, lf);
   }
   if (bRet) {
     if (pLogFont) {
       memcpy(pLogFont, &lf, sizeof(LOGFONTA));
     }
     csFontName = lf.lfFaceName;
     return csFontName;
   }
 #endif
   return csFontName;
@@ skipping 152 matching lines @@
     }
   }
   if (csSub.IsEmpty()) {
     return FALSE;
   }
   csNewFieldName = csSub;
   return TRUE;
 }
 FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName,
                                           int iType) {
-  return ValidateFieldName(csNewFieldName, iType, NULL, NULL);
+  return ValidateFieldName(csNewFieldName, iType, nullptr, nullptr);
 }
 FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormField* pField,
                                           CFX_WideString& csNewFieldName) {
   return pField && !csNewFieldName.IsEmpty() &&
          ValidateFieldName(csNewFieldName,
                            ((CPDF_FormField*)pField)->GetFieldType(), pField,
-                           NULL);
+                           nullptr);
 }
 FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormControl* pControl,
                                           CFX_WideString& csNewFieldName) {
   if (!pControl || csNewFieldName.IsEmpty()) {
     return FALSE;
   }
   CPDF_FormField* pField = ((CPDF_FormControl*)pControl)->GetField();
   return ValidateFieldName(csNewFieldName, pField->GetFieldType(), pField,
                            pControl);
 }
@@ skipping 47 matching lines @@
   if (csFieldName == L"") {
     return m_pFieldTree->m_Root.GetField(index);
   }
   CFieldTree::_Node* pNode = m_pFieldTree->FindNode(csFieldName);
   return pNode ? pNode->GetField(index) : nullptr;
 }
 
 CPDF_FormField* CPDF_InterForm::GetFieldByDict(
     CPDF_Dictionary* pFieldDict) const {
   if (!pFieldDict) {
-    return NULL;
+    return nullptr;
   }
   CFX_WideString csWName = GetFullName(pFieldDict);
   return m_pFieldTree->GetField(csWName);
 }
 
 CPDF_FormControl* CPDF_InterForm::GetControlAtPoint(CPDF_Page* pPage,
                                                     FX_FLOAT pdf_x,
                                                     FX_FLOAT pdf_y,
                                                     int* z_order) const {
   CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArrayBy("Annots");
@@ skipping 217 matching lines @@
   }
   for (size_t i = 0; i < pAnnots->GetCount(); i++) {
     CPDF_Dictionary* pAnnot = pAnnots->GetDictAt(i);
     if (pAnnot && pAnnot->GetStringBy("Subtype") == "Widget") {
       LoadField(pAnnot);
     }
   }
 }
 CPDF_FormField* CPDF_InterForm::AddTerminalField(CPDF_Dictionary* pFieldDict) {
   if (!pFieldDict->KeyExist("T")) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pDict = pFieldDict;
   CFX_WideString csWName = GetFullName(pFieldDict);
   if (csWName.IsEmpty()) {
-    return NULL;
+    return nullptr;
   }
-  CPDF_FormField* pField = NULL;
+  CPDF_FormField* pField = nullptr;
   pField = m_pFieldTree->GetField(csWName);
   if (!pField) {
     CPDF_Dictionary* pParent = pFieldDict;
     if (!pFieldDict->KeyExist("T") &&
         pFieldDict->GetStringBy("Subtype") == "Widget") {
       pParent = pFieldDict->GetDictBy("Parent");
       if (!pParent) {
         pParent = pFieldDict;
       }
     }
@@ skipping 95 matching lines @@
   return ExportToFDF(pdf_path, fields, true, bSimpleFileSpec);
 }
 
 CFDF_Document* CPDF_InterForm::ExportToFDF(
     const CFX_WideStringC& pdf_path,
     const std::vector<CPDF_FormField*>& fields,
     bool bIncludeOrExclude,
     bool bSimpleFileSpec) const {
   CFDF_Document* pDoc = CFDF_Document::CreateNewDoc();
   if (!pDoc) {
-    return NULL;
+    return nullptr;
   }
   CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDictBy("FDF");
   if (!pdf_path.IsEmpty()) {
     if (bSimpleFileSpec) {
       CFX_WideString wsFilePath = CPDF_FileSpec::EncodeFileName(pdf_path);
       pMainDict->SetAtString("F", CFX_ByteString::FromUnicode(wsFilePath));
       pMainDict->SetAtString("UF", PDF_EncodeText(wsFilePath));
     } else {
       CPDF_FileSpec filespec;
       filespec.SetFileName(pdf_path);
@@ skipping 125 matching lines @@
     FDF_ImportField(pField, L"", bNotify);
   }
   if (bNotify && m_pFormNotify)
     m_pFormNotify->AfterFormImportData(this);
   return TRUE;
 }
 
 void CPDF_InterForm::SetFormNotify(IPDF_FormNotify* pNotify) {
   m_pFormNotify = pNotify;
 }