Get rid of NULLs in fpdfsdk/

fpdfsdk/fpdfview.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 "public/fpdfview.h"
 
 #include <memory>
 
@@ skipping 317 matching lines @@
     return nullptr;
   }
 
   CPDF_Parser* pParser = new CPDF_Parser;
   pParser->SetPassword(password);
 
   CPDF_Parser::Error error = pParser->StartParse(pFileAccess);
   if (error != CPDF_Parser::SUCCESS) {
     delete pParser;
     ProcessParseError(error);
-    return NULL;
+    return nullptr;
   }
 #ifdef PDF_ENABLE_XFA
   CPDF_Document* pPDFDoc = pParser->GetDocument();
   if (!pPDFDoc)
-    return NULL;
+    return nullptr;
 
   CPDFXFA_App* pProvider = CPDFXFA_App::GetInstance();
   return new CPDFXFA_Document(pPDFDoc, pProvider);
 #else   // PDF_ENABLE_XFA
   return pParser->GetDocument();
 #endif  // PDF_ENABLE_XFA
 }
 
 #ifdef PDF_ENABLE_XFA
 DLLEXPORT FPDF_BOOL STDCALL FPDF_HasXFAField(FPDF_DOCUMENT document,
@@ skipping 58 matching lines @@
 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadMemDocument(const void* data_buf,
                                                      int size,
                                                      FPDF_BYTESTRING password) {
   CPDF_Parser* pParser = new CPDF_Parser;
   pParser->SetPassword(password);
   CMemFile* pMemFile = new CMemFile((uint8_t*)data_buf, size);
   CPDF_Parser::Error error = pParser->StartParse(pMemFile);
   if (error != CPDF_Parser::SUCCESS) {
     delete pParser;
     ProcessParseError(error);
-    return NULL;
+    return nullptr;
   }
-  CPDF_Document* pDoc = NULL;
-  pDoc = pParser ? pParser->GetDocument() : NULL;
+  CPDF_Document* pDoc = pParser ? pParser->GetDocument() : nullptr;
   CheckUnSupportError(pDoc, error);
   return FPDFDocumentFromCPDFDocument(pParser->GetDocument());
 }
 
 DLLEXPORT FPDF_DOCUMENT STDCALL
 FPDF_LoadCustomDocument(FPDF_FILEACCESS* pFileAccess,
                         FPDF_BYTESTRING password) {
   CPDF_Parser* pParser = new CPDF_Parser;
   pParser->SetPassword(password);
   CPDF_CustomAccess* pFile = new CPDF_CustomAccess(pFileAccess);
   CPDF_Parser::Error error = pParser->StartParse(pFile);
   if (error != CPDF_Parser::SUCCESS) {
     delete pParser;
     ProcessParseError(error);
-    return NULL;
+    return nullptr;
   }
-  CPDF_Document* pDoc = NULL;
-  pDoc = pParser ? pParser->GetDocument() : NULL;
+  CPDF_Document* pDoc = pParser ? pParser->GetDocument() : nullptr;
   CheckUnSupportError(pDoc, error);
   return FPDFDocumentFromCPDFDocument(pParser->GetDocument());
 }
 
 DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc,
                                                 int* fileVersion) {
   if (!fileVersion)
     return FALSE;
 
   *fileVersion = 0;
@@ skipping 107 matching lines @@
   if (bBackgroundAlphaNeeded || bHasImageMask) {
     if (pBitmap) {
       CFX_WindowsDevice WinDC(dc);
 
       if (WinDC.GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
         CFX_DIBitmap* pDst = new CFX_DIBitmap;
         int pitch = pBitmap->GetPitch();
         pDst->Create(size_x, size_y, FXDIB_Rgb32);
         FXSYS_memset(pDst->GetBuffer(), -1, pitch * size_y);
         pDst->CompositeBitmap(0, 0, size_x, size_y, pBitmap, 0, 0,
-                              FXDIB_BLEND_NORMAL, NULL, FALSE, NULL);
+                              FXDIB_BLEND_NORMAL, nullptr, FALSE, nullptr);
         WinDC.StretchDIBits(pDst, 0, 0, size_x, size_y);
         delete pDst;
       } else {
         WinDC.SetDIBits(pBitmap, 0, 0);
       }
     }
   }
   if (bBackgroundAlphaNeeded || bHasImageMask)
     delete pBitmap;
 
@@ skipping 144 matching lines @@
   *device_x = FXSYS_round(device_x_f);
   *device_y = FXSYS_round(device_y_f);
 #endif  // PDF_ENABLE_XFA
 }
 
 DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_Create(int width,
                                                 int height,
                                                 int alpha) {
   std::unique_ptr<CFX_DIBitmap> pBitmap(new CFX_DIBitmap);
   if (!pBitmap->Create(width, height, alpha ? FXDIB_Argb : FXDIB_Rgb32)) {
-    return NULL;
+    return nullptr;
   }
   return pBitmap.release();
 }
 
 DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_CreateEx(int width,
                                                   int height,
                                                   int format,
                                                   void* first_scan,
                                                   int stride) {
   FXDIB_Format fx_format;
   switch (format) {
     case FPDFBitmap_Gray:
       fx_format = FXDIB_8bppRgb;
       break;
     case FPDFBitmap_BGR:
       fx_format = FXDIB_Rgb;
       break;
     case FPDFBitmap_BGRx:
       fx_format = FXDIB_Rgb32;
       break;
     case FPDFBitmap_BGRA:
       fx_format = FXDIB_Argb;
       break;
     default:
-      return NULL;
+      return nullptr;
   }
   CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
   pBitmap->Create(width, height, fx_format, (uint8_t*)first_scan, stride);
   return pBitmap;
 }
 
 DLLEXPORT void STDCALL FPDFBitmap_FillRect(FPDF_BITMAP bitmap,
                                            int left,
                                            int top,
                                            int width,
@@ skipping 85 matching lines @@
   pContext->m_pDevice->SetClip_Rect(
       FX_RECT(start_x, start_y, start_x + size_x, start_y + size_y));
 
   pContext->m_pContext = new CPDF_RenderContext(pPage);
   pContext->m_pContext->AppendLayer(pPage, &matrix);
 
   if (flags & FPDF_ANNOT) {
     pContext->m_pAnnots = new CPDF_AnnotList(pPage);
     FX_BOOL bPrinting = pContext->m_pDevice->GetDeviceClass() != FXDC_DISPLAY;
     pContext->m_pAnnots->DisplayAnnots(pPage, pContext->m_pContext, bPrinting,
-                                       &matrix, TRUE, NULL);
+                                       &matrix, TRUE, nullptr);
   }
 
   pContext->m_pRenderer = new CPDF_ProgressiveRenderer(
       pContext->m_pContext, pContext->m_pDevice, pContext->m_pOptions);
   pContext->m_pRenderer->Start(pause);
   if (bNeedToRestore)
     pContext->m_pDevice->RestoreState(false);
 }
 
 DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document,
@@ skipping 40 matching lines @@
   if (!pDoc)
     return 1;
   CPDF_ViewerPreferences viewRef(pDoc);
   return viewRef.NumCopies();
 }
 
 DLLEXPORT FPDF_PAGERANGE STDCALL
 FPDF_VIEWERREF_GetPrintPageRange(FPDF_DOCUMENT document) {
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
   if (!pDoc)
-    return NULL;
+    return nullptr;
   CPDF_ViewerPreferences viewRef(pDoc);
   return viewRef.PrintPageRange();
 }
 
 DLLEXPORT FPDF_DUPLEXTYPE STDCALL
 FPDF_VIEWERREF_GetDuplex(FPDF_DOCUMENT document) {
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
   if (!pDoc)
     return DuplexUndefined;
   CPDF_ViewerPreferences viewRef(pDoc);
@@ skipping 56 matching lines @@
   if (!str)
     return -1;
   if (!bstr || !length)
     return -1;
   if (length == -1)
     length = FXSYS_strlen(bstr);
 
   if (length == 0) {
     if (str->str) {
       FX_Free(str->str);
-      str->str = NULL;
+      str->str = nullptr;
     }
     str->len = 0;
     return 0;
   }
 
   if (str->str && str->len < length)
     str->str = FX_Realloc(char, str->str, length + 1);
   else if (!str->str)
     str->str = FX_Alloc(char, length + 1);
 
   str->str[length] = 0;
-  if (str->str == NULL)
-    return -1;
-
   FXSYS_memcpy(str->str, bstr, length);
   str->len = length;
 
   return 0;
 }
 
 DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Clear(FPDF_BSTR* str) {
   if (!str)
     return -1;
 
   if (str->str) {
     FX_Free(str->str);
-    str->str = NULL;
+    str->str = nullptr;
   }
   str->len = 0;
   return 0;
 }
 #endif  // PDF_ENABLE_XFA
 
 DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDest(FPDF_DOCUMENT document,
                                               int index,
                                               void* buffer,
                                               long* buflen) {
@@ skipping 55 matching lines @@
   if (!buffer) {
     *buflen = len;
   } else if (*buflen >= len) {
     memcpy(buffer, utf16Name.c_str(), len);
     *buflen = len;
   } else {
     *buflen = -1;
   }
   return (FPDF_DEST)pDestObj;
 }