Remove NULL in xfa/

xfa/fxfa/app/xfa_ffwidget.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 "xfa/fxfa/include/xfa_ffwidget.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 105 matching lines @@
     GetRectWithoutRotate(rtBorder);
     CXFA_Margin margin = border.GetMargin();
     if (margin) {
       XFA_RectWidthoutMargin(rtBorder, margin);
     }
     rtBorder.Normalize();
     DrawBorder(pGS, border, rtBorder, pMatrix);
   }
 }
 FX_BOOL CXFA_FFWidget::IsLoaded() {
-  return m_pPageView != NULL;
+  return !!m_pPageView;
 }
 FX_BOOL CXFA_FFWidget::LoadWidget() {
   PerformLayout();
   return TRUE;
 }
 void CXFA_FFWidget::UnloadWidget() {}
 FX_BOOL CXFA_FFWidget::PerformLayout() {
   ReCacheWidgetRect();
   return TRUE;
 }
@@ skipping 261 matching lines @@
   GetRectWithoutRotate(rtLayout);
   return rtLayout.width < 0.1f && rtLayout.height < 0.1f;
 }
 CXFA_FFWidget* CXFA_FFWidget::GetParent() {
   CXFA_Node* pParentNode =
       m_pDataAcc->GetNode()->GetNodeItem(XFA_NODEITEM_Parent);
   if (pParentNode) {
     CXFA_WidgetAcc* pParentWidgetAcc =
         static_cast<CXFA_WidgetAcc*>(pParentNode->GetWidgetData());
     if (pParentWidgetAcc) {
-      return pParentWidgetAcc->GetNextWidget(NULL);
+      return pParentWidgetAcc->GetNextWidget(nullptr);
     }
   }
-  return NULL;
+  return nullptr;
 }
 FX_BOOL CXFA_FFWidget::IsAncestorOf(CXFA_FFWidget* pWidget) {
   if (!pWidget) {
     return FALSE;
   }
   CXFA_Node* pNode = m_pDataAcc->GetNode();
   CXFA_Node* pChildNode = pWidget->GetDataAcc()->GetNode();
   while (pChildNode) {
     if (pChildNode == pNode) {
       return TRUE;
@@ skipping 155 matching lines @@
   FX_BOOL StartDIBSource();
   void CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
                          int left,
                          int top,
                          FX_ARGB mask_argb,
                          int bitmap_alpha,
                          int blend_mode,
                          int Transparency);
 };
 CXFA_ImageRenderer::CXFA_ImageRenderer() {
-  m_pDevice = NULL;
+  m_pDevice = nullptr;
   m_Status = 0;
-  m_pDIBSource = NULL;
-  m_pCloneConvert = NULL;
+  m_pDIBSource = nullptr;
+  m_pCloneConvert = nullptr;
   m_BitmapAlpha = 255;
   m_FillArgb = 0;
   m_Flags = 0;
-  m_DeviceHandle = NULL;
+  m_DeviceHandle = nullptr;
   m_BlendType = FXDIB_BLEND_NORMAL;
   m_Result = TRUE;
   m_bPrint = FALSE;
 }
 
 CXFA_ImageRenderer::~CXFA_ImageRenderer() {
   delete m_pCloneConvert;
   if (m_DeviceHandle)
     m_pDevice->CancelDIBits(m_DeviceHandle);
 }
@@ skipping 129 matching lines @@
   return FALSE;
 }
 
 void CXFA_ImageRenderer::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
                                            int left,
                                            int top,
                                            FX_ARGB mask_argb,
                                            int bitmap_alpha,
                                            int blend_mode,
                                            int Transparency) {
-  if (pDIBitmap == NULL) {
+  if (!pDIBitmap) {
     return;
   }
   bool bIsolated = !!(Transparency & PDFTRANS_ISOLATED);
   bool bGroup = !!(Transparency & PDFTRANS_GROUP);
   if (blend_mode == FXDIB_BLEND_NORMAL) {
     if (!pDIBitmap->IsAlphaMask()) {
       if (bitmap_alpha < 255) {
         pDIBitmap->MultiplyAlpha(bitmap_alpha);
       }
       if (m_pDevice->SetDIBits(pDIBitmap, left, top)) {
@@ skipping 18 matching lines @@
   if (bGetBackGround) {
     if (bIsolated || !bGroup) {
       if (pDIBitmap->IsAlphaMask()) {
         return;
       }
       m_pDevice->SetDIBitsWithBlend(pDIBitmap, left, top, blend_mode);
     } else {
       FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
                    top + pDIBitmap->GetHeight());
       rect.Intersect(m_pDevice->GetClipBox());
-      CFX_DIBitmap* pClone = NULL;
+      CFX_DIBitmap* pClone = nullptr;
       FX_BOOL bClone = FALSE;
       if (m_pDevice->GetBackDrop() && m_pDevice->GetBitmap()) {
         bClone = TRUE;
         pClone = m_pDevice->GetBackDrop()->Clone(&rect);
         CFX_DIBitmap* pForeBitmap = m_pDevice->GetBitmap();
         pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
                                 pForeBitmap, rect.left, rect.top);
         left = left >= 0 ? 0 : left;
         top = top >= 0 ? 0 : top;
         if (!pDIBitmap->IsAlphaMask())
@@ skipping 22 matching lines @@
   if (pDIBitmap->HasAlpha() &&
       !(m_pDevice->GetRenderCaps() & FXRC_ALPHA_IMAGE)) {
     CFX_DIBitmap* pCloneConvert = pDIBitmap->CloneConvert(FXDIB_Rgb);
     if (!pCloneConvert) {
       return;
     }
     CXFA_ImageRenderer imageRender;
     FX_BOOL bRet = imageRender.Start(m_pDevice, pCloneConvert, m_FillArgb,
                                      m_BitmapAlpha, &m_ImageMatrix, m_Flags);
     while (bRet) {
-      bRet = imageRender.Continue(NULL);
+      bRet = imageRender.Continue(nullptr);
     }
     delete pCloneConvert;
     return;
   }
 }
 void XFA_DrawImage(CFX_Graphics* pGS,
                    const CFX_RectF& rtImage,
                    CFX_Matrix* pMatrix,
                    CFX_DIBitmap* pDIBitmap,
                    int32_t iAspect,
@@ skipping 53 matching lines @@
   CFX_PathData path;
   path.AppendRect(rtImage.left, rtImage.bottom(), rtImage.right(), rtImage.top);
   pRenderDevice->SetClip_PathFill(&path, pMatrix, FXFILL_WINDING);
   CFX_Matrix mtImage(1, 0, 0, -1, 0, 1);
   mtImage.Concat(rtFit.width, 0, 0, rtFit.height, rtFit.left, rtFit.top);
   mtImage.Concat(*pMatrix);
   CXFA_ImageRenderer imageRender;
   FX_BOOL bRet = imageRender.Start(pRenderDevice, pDIBitmap, 0, 255, &mtImage,
                                    FXDIB_INTERPOL);
   while (bRet) {
-    bRet = imageRender.Continue(NULL);
+    bRet = imageRender.Continue(nullptr);
   }
   pRenderDevice->RestoreState(false);
 }
 
 static const uint8_t g_inv_base64[128] = {
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
     255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
     255, 255, 255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
@@ skipping 14 matching lines @@
     if ((pStr[i] & 128) == 0) {
       if (g_inv_base64[pStr[i]] != 0xFF || pStr[i] == '=') {
         pCP[j++] = pStr[i];
       }
     }
   }
   pCP[j] = '\0';
   return pCP;
 }
 static int32_t XFA_Base64Decode(const FX_CHAR* pStr, uint8_t* pOutBuffer) {
-  if (pStr == NULL) {
+  if (!pStr) {
     return 0;
   }
   uint8_t* pBuffer =
       XFA_RemoveBase64Whitespace((uint8_t*)pStr, FXSYS_strlen((FX_CHAR*)pStr));
-  if (pBuffer == NULL) {
+  if (!pBuffer) {
     return 0;
   }
   int32_t iLen = FXSYS_strlen((FX_CHAR*)pBuffer);
   int32_t i = 0, j = 0;
   uint32_t dwLimb = 0;
   for (; i + 3 < iLen; i += 4) {
     if (pBuffer[i] == '=' || pBuffer[i + 1] == '=' || pBuffer[i + 2] == '=' ||
         pBuffer[i + 3] == '=') {
       if (pBuffer[i] == '=' || pBuffer[i + 1] == '=') {
         break;
@@ skipping 23 matching lines @@
     }
   }
   FX_Free(pBuffer);
   return j;
 }
 
 static const FX_CHAR g_base64_chars[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 FX_CHAR* XFA_Base64Encode(const uint8_t* buf, int32_t buf_len) {
-  FX_CHAR* out = NULL;
+  FX_CHAR* out = nullptr;
   int i, j;
   uint32_t limb;
   out = FX_Alloc(FX_CHAR, ((buf_len * 8 + 5) / 6) + 5);
   for (i = 0, j = 0, limb = 0; i + 2 < buf_len; i += 3, j += 4) {
     limb = ((uint32_t)buf[i] << 16) | ((uint32_t)buf[i + 1] << 8) |
            ((uint32_t)buf[i + 2]);
     out[j] = g_base64_chars[(limb >> 18) & 63];
     out[j + 1] = g_base64_chars[(limb >> 12) & 63];
     out[j + 2] = g_base64_chars[(limb >> 6) & 63];
     out[j + 3] = g_base64_chars[(limb)&63];
@@ skipping 44 matching lines @@
 CFX_DIBitmap* XFA_LoadImageData(CXFA_FFDoc* pDoc,
                                 CXFA_Image* pImage,
                                 FX_BOOL& bNameImage,
                                 int32_t& iImageXDpi,
                                 int32_t& iImageYDpi) {
   CFX_WideString wsHref;
   pImage->GetHref(wsHref);
   CFX_WideString wsImage;
   pImage->GetContent(wsImage);
   if (wsHref.IsEmpty() && wsImage.IsEmpty()) {
-    return NULL;
+    return nullptr;
   }
   CFX_WideString wsContentType;
   pImage->GetContentType(wsContentType);
   FXCODEC_IMAGE_TYPE type = XFA_GetImageType(wsContentType);
   CFX_ByteString bsContent;
-  uint8_t* pImageBuffer = NULL;
-  IFX_FileRead* pImageFileRead = NULL;
+  uint8_t* pImageBuffer = nullptr;
+  IFX_FileRead* pImageFileRead = nullptr;
   if (wsImage.GetLength() > 0) {
     XFA_ATTRIBUTEENUM iEncoding =
         (XFA_ATTRIBUTEENUM)pImage->GetTransferEncoding();
     if (iEncoding == XFA_ATTRIBUTEENUM_Base64) {
       CFX_ByteString bsData = wsImage.UTF8Encode();
       int32_t iLength = bsData.GetLength();
       pImageBuffer = FX_Alloc(uint8_t, iLength);
       int32_t iRead = XFA_Base64Decode(bsData.c_str(), pImageBuffer);
       if (iRead > 0) {
         pImageFileRead = FX_CreateMemoryStream(pImageBuffer, iRead);
@@ skipping 11 matching lines @@
           pDoc->GetPDFNamedImage(wsURL.AsStringC(), iImageXDpi, iImageYDpi);
       if (pBitmap) {
         bNameImage = TRUE;
         return pBitmap;
       }
     }
     pImageFileRead = pDoc->GetDocProvider()->OpenLinkedFile(pDoc, wsURL);
   }
   if (!pImageFileRead) {
     FX_Free(pImageBuffer);
-    return NULL;
+    return nullptr;
   }
   bNameImage = FALSE;
   CFX_DIBitmap* pBitmap =
       XFA_LoadImageFromBuffer(pImageFileRead, type, iImageXDpi, iImageYDpi);
   FX_Free(pImageBuffer);
   pImageFileRead->Release();
   return pBitmap;
 }
 static FXDIB_Format XFA_GetDIBFormat(FXCODEC_IMAGE_TYPE type,
                                      int32_t iComponents,
@@ skipping 14 matching lines @@
       break;
   }
   return dibFormat;
 }
 CFX_DIBitmap* XFA_LoadImageFromBuffer(IFX_FileRead* pImageFileRead,
                                       FXCODEC_IMAGE_TYPE type,
                                       int32_t& iImageXDpi,
                                       int32_t& iImageYDpi) {
   CFX_GEModule* pGeModule = CFX_GEModule::Get();
   if (!pGeModule) {
-    return NULL;
+    return nullptr;
   }
   CCodec_ModuleMgr* pCodecMgr = pGeModule->GetCodecModule();
   if (!pCodecMgr) {
-    return NULL;
+    return nullptr;
   }
   CFX_DIBAttribute dibAttr;
-  CFX_DIBitmap* pBitmap = NULL;
+  CFX_DIBitmap* pBitmap = nullptr;
   CCodec_ProgressiveDecoder* pProgressiveDecoder =
       pCodecMgr->CreateProgressiveDecoder();
   pProgressiveDecoder->LoadImageInfo(pImageFileRead, type, &dibAttr, false);
   switch (dibAttr.m_wDPIUnit) {
     case FXCODEC_RESUNIT_CENTIMETER:
       dibAttr.m_nXDPI = (int32_t)(dibAttr.m_nXDPI * 2.54f);
       dibAttr.m_nYDPI = (int32_t)(dibAttr.m_nYDPI * 2.54f);
       break;
     case FXCODEC_RESUNIT_METER:
       dibAttr.m_nXDPI = (int32_t)(dibAttr.m_nXDPI / (FX_FLOAT)100 * 2.54f);
@@ skipping 901 matching lines @@
   }
   XFA_BOX_Fill(box, strokes, pGS, rtWidget, pMatrix, dwFlags);
   XFA_BOX_Stroke(box, strokes, pGS, rtWidget, pMatrix, dwFlags);
 }
 
 CXFA_CalcData::CXFA_CalcData() : m_iRefCount(0) {}
 
 CXFA_CalcData::~CXFA_CalcData() {
   m_Globals.RemoveAll();
 }