Get rid of most instance of 'foo == NULL'

core/src/fpdfapi/fpdf_render/fpdf_render_text.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 "render_int.h"
 
 #include "core/include/fpdfapi/fpdf_pageobj.h"
 #include "core/include/fpdfapi/fpdf_render.h"
@@ skipping 151 matching lines @@
       top = top_line;
       if (image_matrix.a < 0) {
         image_matrix.Scale(retinaScaleX, retinaScaleY);
         left = FXSYS_round(image_matrix.e + image_matrix.a);
       } else {
         left = FXSYS_round(image_matrix.e);
       }
     } else {
     }
   }
-  if (pResBitmap == NULL) {
+  if (!pResBitmap) {
     image_matrix.Scale(retinaScaleX, retinaScaleY);
     pResBitmap = pBitmap->TransformTo(&image_matrix, left, top);
   }
-  if (pResBitmap == NULL) {
+  if (!pResBitmap) {
     return NULL;
   }
   CFX_GlyphBitmap* pGlyph = new CFX_GlyphBitmap;
   pGlyph->m_Left = left;
   pGlyph->m_Top = -top;
   pGlyph->m_Bitmap.TakeOver(pResBitmap);
   delete pResBitmap;
   return pGlyph;
 }
 void _CPDF_UniqueKeyGen::Generate(int count, ...) {
@@ skipping 24 matching lines @@
   if (pClippingPath) {
     bClip = TRUE;
   } else {
     switch (text_render_mode) {
       case 0:
       case 4:
         bFill = TRUE;
         break;
       case 1:
       case 5:
-        if (pFont->GetFace() == NULL &&
+        if (!pFont->GetFace() &&
             !(pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
           bFill = TRUE;
         } else {
           bStroke = TRUE;
         }
         break;
       case 2:
       case 6:
-        if (pFont->GetFace() == NULL &&
+        if (!pFont->GetFace() &&
             !(pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
           bFill = TRUE;
         } else {
           bFill = bStroke = TRUE;
         }
         break;
       case 3:
       case 7:
         return TRUE;
       default:
@@ skipping 57 matching lines @@
         m_pDevice, textobj->m_nChars, textobj->m_pCharCodes,
         textobj->m_pCharPos, pFont, font_size, &text_matrix, pDeviceMatrix,
         textobj->m_GraphState, fill_argb, stroke_argb, pClippingPath, flag);
   }
   text_matrix.Concat(*pObj2Device);
   return CPDF_TextRenderer::DrawNormalText(
       m_pDevice, textobj->m_nChars, textobj->m_pCharCodes, textobj->m_pCharPos,
       pFont, font_size, &text_matrix, fill_argb, &m_Options);
 }
 CPDF_Type3Cache* CPDF_RenderStatus::GetCachedType3(CPDF_Type3Font* pFont) {
-  if (pFont->m_pDocument == NULL) {
+  if (!pFont->m_pDocument) {
     return NULL;
   }
   pFont->m_pDocument->GetPageData()->GetFont(pFont->GetFontDict(), FALSE);
   return pFont->m_pDocument->GetRenderData()->GetCachedType3(pFont);
 }
 static void ReleaseCachedType3(CPDF_Type3Font* pFont) {
-  if (pFont->m_pDocument == NULL) {
+  if (!pFont->m_pDocument) {
     return;
   }
   pFont->m_pDocument->GetRenderData()->ReleaseCachedType3(pFont);
   pFont->m_pDocument->GetPageData()->ReleaseFont(pFont->GetFontDict());
 }
 FX_BOOL CPDF_Type3Char::LoadBitmap(CPDF_RenderContext* pContext) {
-  if (m_pBitmap || m_pForm == NULL) {
+  if (m_pBitmap || !m_pForm) {
     return TRUE;
   }
   if (m_pForm->CountObjects() == 1 && !m_bColored) {
     CPDF_PageObject* pPageObj =
         m_pForm->GetObjectAt(m_pForm->GetFirstObjectPosition());
     if (pPageObj->m_Type == PDFPAGE_IMAGE) {
       CPDF_ImageObject* pImage = (CPDF_ImageObject*)pPageObj;
       m_ImageMatrix = pImage->m_Matrix;
       const CFX_DIBSource* pSource = pImage->m_pImage->LoadDIBSource();
       if (pSource) {
@@ skipping 50 matching lines @@
   FX_DWORD* pChars = textobj->m_pCharCodes;
   if (textobj->m_nChars == 1) {
     pChars = (FX_DWORD*)(&textobj->m_pCharCodes);
   }
   for (int iChar = 0; iChar < textobj->m_nChars; iChar++) {
     FX_DWORD charcode = pChars[iChar];
     if (charcode == (FX_DWORD)-1) {
       continue;
     }
     CPDF_Type3Char* pType3Char = pType3Font->LoadChar(charcode);
-    if (pType3Char == NULL) {
+    if (!pType3Char) {
       continue;
     }
     CFX_AffineMatrix matrix = char_matrix;
     matrix.e += iChar ? textobj->m_pCharPos[iChar - 1] : 0;
     matrix.Concat(text_matrix);
     matrix.Concat(*pObj2Device);
     if (!pType3Char->LoadBitmap(m_pContext)) {
       if (pGlyphAndPos) {
         for (int i = 0; i < iChar; i++) {
           FXTEXT_GLYPHPOS& glyph = pGlyphAndPos[i];
-          if (glyph.m_pGlyph == NULL) {
+          if (!glyph.m_pGlyph) {
             continue;
           }
           m_pDevice->SetBitMask(&glyph.m_pGlyph->m_Bitmap,
                                 glyph.m_OriginX + glyph.m_pGlyph->m_Left,
                                 glyph.m_OriginY - glyph.m_pGlyph->m_Top,
                                 fill_argb);
         }
         FX_Free(pGlyphAndPos);
         pGlyphAndPos = NULL;
       }
@@ skipping 37 matching lines @@
         matrix.Scale(sa, sd);
         status.RenderObjectList(pType3Char->m_pForm, &matrix);
         m_pDevice->SetDIBits(bitmap_device.GetBitmap(), rect.left, rect.top);
       }
       delete pStates;
     } else if (pType3Char->m_pBitmap) {
       if (device_class == FXDC_DISPLAY) {
         CPDF_Type3Cache* pCache = GetCachedType3(pType3Font);
         refTypeCache.m_dwCount++;
         CFX_GlyphBitmap* pBitmap = pCache->LoadGlyph(charcode, &matrix, sa, sd);
-        if (pBitmap == NULL) {
+        if (!pBitmap) {
           continue;
         }
         int origin_x = FXSYS_round(matrix.e);
         int origin_y = FXSYS_round(matrix.f);
         if (pGlyphAndPos) {
           pGlyphAndPos[iChar].m_pGlyph = pBitmap;
           pGlyphAndPos[iChar].m_OriginX = origin_x;
           pGlyphAndPos[iChar].m_OriginY = origin_y;
         } else {
           m_pDevice->SetBitMask(&pBitmap->m_Bitmap, origin_x + pBitmap->m_Left,
@@ skipping 18 matching lines @@
         FXGE_GetGlyphsBBox(pGlyphAndPos, textobj->m_nChars, 0, sa, sd);
     CFX_DIBitmap bitmap;
     if (!bitmap.Create((int)(rect.Width() * sa), (int)(rect.Height() * sd),
                        FXDIB_8bppMask)) {
       FX_Free(pGlyphAndPos);
       return TRUE;
     }
     bitmap.Clear(0);
     for (int iChar = 0; iChar < textobj->m_nChars; iChar++) {
       FXTEXT_GLYPHPOS& glyph = pGlyphAndPos[iChar];
-      if (glyph.m_pGlyph == NULL) {
+      if (!glyph.m_pGlyph) {
         continue;
       }
       bitmap.TransferBitmap(
           (int)((glyph.m_OriginX + glyph.m_pGlyph->m_Left - rect.left) * sa),
           (int)((glyph.m_OriginY - glyph.m_pGlyph->m_Top - rect.top) * sd),
           glyph.m_pGlyph->m_Bitmap.GetWidth(),
           glyph.m_pGlyph->m_Bitmap.GetHeight(), &glyph.m_pGlyph->m_Bitmap, 0,
           0);
     }
     m_pDevice->SetBitMask(&bitmap, rect.left, rect.top, fill_argb);
@@ skipping 45 matching lines @@
     charpos.m_ExtGID = pFont->GlyphFromCharCodeExt(CharCode);
 #endif
     if (!pFont->IsEmbedded() && pFont->GetFontType() != PDFFONT_CIDFONT) {
       charpos.m_FontCharWidth = pFont->GetCharWidthF(CharCode);
     } else {
       charpos.m_FontCharWidth = 0;
     }
     charpos.m_OriginX = iChar ? pCharPos[iChar - 1] : 0;
     charpos.m_OriginY = 0;
     charpos.m_bGlyphAdjust = FALSE;
-    if (pCIDFont == NULL) {
+    if (!pCIDFont) {
       continue;
     }
     FX_WORD CID = pCIDFont->CIDFromCharCode(CharCode);
     if (bVertWriting) {
       charpos.m_OriginY = charpos.m_OriginX;
       charpos.m_OriginX = 0;
       short vx, vy;
       pCIDFont->GetVertOrigin(CID, vx, vy);
       charpos.m_OriginX -= FontSize * vx / 1000;
       charpos.m_OriginY -= FontSize * vy / 1000;
@@ skipping 185 matching lines @@
   }
   CFX_FaceCache* pFaceCache = pCache->GetCachedFace(&pFont->m_Font);
   FX_FONTCACHE_DEFINE(pCache, &pFont->m_Font);
   CPDF_CharPosList CharPosList;
   CharPosList.Load(textobj->m_nChars, textobj->m_pCharCodes,
                    textobj->m_pCharPos, pFont, font_size);
   for (FX_DWORD i = 0; i < CharPosList.m_nChars; i++) {
     FXTEXT_CHARPOS& charpos = CharPosList.m_pCharPos[i];
     const CFX_PathData* pPath = pFaceCache->LoadGlyphPath(
         &pFont->m_Font, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
-    if (pPath == NULL) {
+    if (!pPath) {
       continue;
     }
     CPDF_PathObject path;
     path.m_GraphState = textobj->m_GraphState;
     path.m_ColorState = textobj->m_ColorState;
     CFX_AffineMatrix matrix;
     if (charpos.m_bGlyphAdjust)
       matrix.Set(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
                  charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
     matrix.Concat(font_size, 0, 0, font_size, charpos.m_OriginX,
                   charpos.m_OriginY);
     path.m_Path.New()->Append(pPath, &matrix);
     path.m_Matrix = *pTextMatrix;
     path.m_bStroke = bStroke;
     path.m_FillType = bFill ? FXFILL_WINDING : 0;
     path.CalcBoundingBox();
     ProcessPath(&path, pObj2Device);
   }
 }
 
 CFX_PathData* CPDF_Font::LoadGlyphPath(FX_DWORD charcode, int dest_width) {
   int glyph_index = GlyphFromCharCode(charcode);
   if (!m_Font.GetFace())
     return nullptr;
   return m_Font.LoadGlyphPath(glyph_index, dest_width);
 }