Get rid of NULLs in core/

core/fxge/apple/fx_quartz_device.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 "core/fxcrt/include/fx_ext.h"
 
 #ifndef _SKIA_SUPPORT_
 #include "core/fxge/agg/fx_agg_driver.h"
 #endif
 
 #include "core/fxge/dib/dib_int.h"
 #include "core/fxge/ge/fx_text_int.h"
 #include "core/fxge/include/fx_freetype.h"
 #include "core/fxge/include/fx_ge.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
 #include "core/fxge/apple/apple_int.h"
 #include "core/fxge/include/fx_ge_apple.h"
 #ifndef CGFLOAT_IS_DOUBLE
 #error Expected CGFLOAT_IS_DOUBLE to be defined by CoreGraphics headers
 #endif
 
 void* CQuartz2D::createGraphics(CFX_DIBitmap* pBitmap) {
   if (!pBitmap) {
-    return NULL;
+    return nullptr;
   }
   CGBitmapInfo bmpInfo = kCGBitmapByteOrder32Little;
   switch (pBitmap->GetFormat()) {
     case FXDIB_Rgb32:
       bmpInfo |= kCGImageAlphaNoneSkipFirst;
       break;
     case FXDIB_Argb:
     default:
-      return NULL;
+      return nullptr;
   }
   CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
   CGContextRef context = CGBitmapContextCreate(
       pBitmap->GetBuffer(), pBitmap->GetWidth(), pBitmap->GetHeight(), 8,
       pBitmap->GetPitch(), colorSpace, bmpInfo);
   CGColorSpaceRelease(colorSpace);
   return context;
 }
 void CQuartz2D::destroyGraphics(void* graphics) {
   if (graphics) {
     CGContextRelease((CGContextRef)graphics);
   }
 }
 void* CQuartz2D::CreateFont(const uint8_t* pFontData, uint32_t dwFontSize) {
-  CGDataProviderRef pDataProvider =
-      CGDataProviderCreateWithData(NULL, pFontData, (size_t)dwFontSize, NULL);
-  if (NULL == pDataProvider) {
-    return NULL;
-  }
+  CGDataProviderRef pDataProvider = CGDataProviderCreateWithData(
+      nullptr, pFontData, (size_t)dwFontSize, nullptr);
+  if (!pDataProvider)
+    return nullptr;
+
   CGFontRef pCGFont = CGFontCreateWithDataProvider(pDataProvider);
   CGDataProviderRelease(pDataProvider);
   return pCGFont;
 }
 void CQuartz2D::DestroyFont(void* pFont) {
   CGFontRelease((CGFontRef)pFont);
 }
 void CQuartz2D::setGraphicsTextMatrix(void* graphics, CFX_Matrix* matrix) {
   if (!graphics || !matrix) {
     return;
@@ skipping 51 matching lines @@
     CGContextSaveGState((CGContextRef)graphics);
   }
 }
 void CQuartz2D::restoreGraphicsState(void* graphics) {
   if (graphics) {
     CGContextRestoreGState((CGContextRef)graphics);
   }
 }
 static CGContextRef createContextWithBitmap(CFX_DIBitmap* pBitmap) {
   if (!pBitmap || pBitmap->IsCmykImage() || pBitmap->GetBPP() < 32) {
-    return NULL;
+    return nullptr;
   }
   CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Little;
   if (pBitmap->HasAlpha()) {
     bitmapInfo |= kCGImageAlphaPremultipliedFirst;
   } else {
     bitmapInfo |= kCGImageAlphaNoneSkipFirst;
   }
   CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
   CGContextRef context = CGBitmapContextCreate(
       pBitmap->GetBuffer(), pBitmap->GetWidth(), pBitmap->GetHeight(), 8,
@@ skipping 331 matching lines @@
   }
   if (!(m_renderCaps | FXRC_GET_BITS)) {
     return FALSE;
   }
   CGPoint pt = CGPointMake(left, top);
   pt = CGPointApplyAffineTransform(pt, m_foxitDevice2User);
   CGAffineTransform ctm = CGContextGetCTM(m_context);
   pt.x *= FXSYS_fabs(ctm.a);
   pt.y *= FXSYS_fabs(ctm.d);
   CGImageRef image = CGBitmapContextCreateImage(m_context);
-  if (NULL == image) {
+  if (!image)
     return FALSE;
-  }
+
   CGFloat width = (CGFloat)bitmap->GetWidth();
   CGFloat height = (CGFloat)bitmap->GetHeight();
   if (width + pt.x > m_width) {
     width -= (width + pt.x - m_width);
   }
   if (height + pt.y > m_height) {
     height -= (height + pt.y - m_height);
   }
   CGImageRef subImage = CGImageCreateWithImageInRect(
       image, CGRectMake(pt.x, pt.y, width, height));
@@ skipping 48 matching lines @@
   src_height /= scale_y;
   CGRect rect_fx = CGRectMake(dest_left, dest_top, src_width, src_height);
   CGRect rect_usr = CGRectApplyAffineTransform(rect_fx, m_foxitDevice2User);
   CGContextBeginPath(m_context);
   CGContextAddRect(m_context, rect_usr);
   CGContextClip(m_context);
   rect_usr.size =
       CGSizeMake(pBitmap->GetWidth() / scale_x, pBitmap->GetHeight() / scale_y);
   rect_usr = CGRectOffset(rect_usr, -src_left, -src_top);
   CG_SetImageTransform(dest_left, dest_top, src_width, src_height, &rect_usr);
-  CFX_DIBitmap* pBitmap1 = NULL;
+  CFX_DIBitmap* pBitmap1 = nullptr;
   if (pBitmap->IsAlphaMask()) {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
-    if (NULL == pBitmap1) {
+    if (!pBitmap1) {
       RestoreState(false);
       return FALSE;
     }
     CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(
-        NULL, pBitmap1->GetBuffer(),
-        pBitmap1->GetPitch() * pBitmap1->GetHeight(), NULL);
+        nullptr, pBitmap1->GetBuffer(),
+        pBitmap1->GetPitch() * pBitmap1->GetHeight(), nullptr);
     CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
     CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
     CGImageRef pImage = CGImageCreate(
         pBitmap1->GetWidth(), pBitmap1->GetHeight(), pBitmap1->GetBPP(),
         pBitmap1->GetBPP(), pBitmap1->GetPitch(), pColorSpace, bitmapInfo,
-        pBitmapProvider, NULL, true, kCGRenderingIntentDefault);
+        pBitmapProvider, nullptr, true, kCGRenderingIntentDefault);
     CGContextClipToMask(m_context, rect_usr, pImage);
     CGContextSetRGBFillColor(m_context, FXARGB_R(argb) / 255.f,
                              FXARGB_G(argb) / 255.f, FXARGB_B(argb) / 255.f,
                              FXARGB_A(argb) / 255.f);
     CGContextFillRect(m_context, rect_usr);
     CGImageRelease(pImage);
     CGColorSpaceRelease(pColorSpace);
     CGDataProviderRelease(pBitmapProvider);
     if (pBitmap1 != pBitmap) {
       delete pBitmap1;
     }
     RestoreState(false);
     return TRUE;
   }
   if (pBitmap->GetBPP() < 32) {
     pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
   } else {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
   }
-  if (NULL == pBitmap1) {
+  if (!pBitmap1) {
     RestoreState(false);
     return FALSE;
   }
   if (pBitmap1->HasAlpha()) {
     if (pBitmap1 == pBitmap) {
       pBitmap1 = pBitmap->Clone();
       if (!pBitmap1) {
         RestoreState(false);
         return FALSE;
       }
@@ skipping 54 matching lines @@
   CGRect rect = CGRectMake(dest_left, dest_top, dest_width, dest_height);
   rect = CGRectApplyAffineTransform(rect, m_foxitDevice2User);
   if (FXDIB_BICUBIC_INTERPOL == flags) {
     CGContextSetInterpolationQuality(m_context, kCGInterpolationHigh);
   } else if (FXDIB_DOWNSAMPLE == flags) {
     CGContextSetInterpolationQuality(m_context, kCGInterpolationNone);
   } else {
     CGContextSetInterpolationQuality(m_context, kCGInterpolationMedium);
   }
   CG_SetImageTransform(dest_left, dest_top, dest_width, dest_height);
-  CFX_DIBitmap* pBitmap1 = NULL;
+  CFX_DIBitmap* pBitmap1 = nullptr;
   if (pBitmap->IsAlphaMask()) {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
-    if (NULL == pBitmap1) {
+    if (!pBitmap1) {
       RestoreState(false);
       return FALSE;
     }
     CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(
-        NULL, pBitmap1->GetBuffer(),
-        pBitmap1->GetPitch() * pBitmap1->GetHeight(), NULL);
+        nullptr, pBitmap1->GetBuffer(),
+        pBitmap1->GetPitch() * pBitmap1->GetHeight(), nullptr);
     CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
     CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
     CGImageRef pImage = CGImageCreate(
         pBitmap1->GetWidth(), pBitmap1->GetHeight(), pBitmap1->GetBPP(),
         pBitmap1->GetBPP(), pBitmap1->GetPitch(), pColorSpace, bitmapInfo,
-        pBitmapProvider, NULL, true, kCGRenderingIntentDefault);
+        pBitmapProvider, nullptr, true, kCGRenderingIntentDefault);
     CGContextClipToMask(m_context, rect, pImage);
     CGContextSetRGBFillColor(m_context, FXARGB_R(argb) / 255.f,
                              FXARGB_G(argb) / 255.f, FXARGB_B(argb) / 255.f,
                              FXARGB_A(argb) / 255.f);
     CGContextFillRect(m_context, rect);
     CGImageRelease(pImage);
     CGColorSpaceRelease(pColorSpace);
     CGDataProviderRelease(pBitmapProvider);
     if (pBitmap1 != pBitmap) {
       delete pBitmap1;
     }
     RestoreState(false);
     return TRUE;
   }
   if (pBitmap->GetBPP() < 32) {
     pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
   } else {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
   }
-  if (NULL == pBitmap1) {
+  if (!pBitmap1) {
     RestoreState(false);
     return FALSE;
   }
   if (pBitmap1->HasAlpha()) {
     if (pBitmap1 == pBitmap) {
       pBitmap1 = pBitmap->Clone();
       if (!pBitmap1) {
         RestoreState(false);
         return FALSE;
       }
@@ skipping 88 matching lines @@
 }
 FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int nChars,
                                                const FXTEXT_CHARPOS* pCharPos,
                                                CFX_Font* pFont,
                                                CFX_FontCache* pCache,
                                                const CFX_Matrix* pObject2Device,
                                                FX_FLOAT font_size,
                                                uint32_t color,
                                                int alpha_flag,
                                                void* pIccTransform) {
-  if (NULL == pFont || NULL == m_context)
+  if (!pFont || !m_context)
     return FALSE;
   FX_BOOL bBold = pFont->IsBold();
   if (!bBold && pFont->GetSubstFont() &&
       pFont->GetSubstFont()->m_Weight >= 500 &&
       pFont->GetSubstFont()->m_Weight <= 600) {
     return FALSE;
   }
   SaveState();
   CGContextSetTextDrawingMode(m_context, kCGTextFillClip);
   FX_BOOL ret = FALSE;
   int32_t i = 0;
   while (i < nChars) {
     if (pCharPos[i].m_bGlyphAdjust || font_size < 0) {
       if (i > 0) {
-        ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, NULL, pObject2Device,
-                             font_size, color, alpha_flag, pIccTransform);
+        ret =
+            CG_DrawGlypRun(i, pCharPos, pFont, pCache, nullptr, pObject2Device,
+                           font_size, color, alpha_flag, pIccTransform);
         if (!ret) {
           RestoreState(false);
           return ret;
         }
       }
       const FXTEXT_CHARPOS* char_pos = pCharPos + i;
       CFX_Matrix glphy_matrix;
       if (font_size < 0) {
         glphy_matrix.Concat(-1, 0, 0, -1, 0, 0);
       }
@@ skipping 11 matching lines @@
       }
       i++;
       pCharPos += i;
       nChars -= i;
       i = 0;
     } else {
       i++;
     }
   }
   if (i > 0) {
-    ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, NULL, pObject2Device,
+    ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, nullptr, pObject2Device,
                          font_size, color, alpha_flag, pIccTransform);
   }
   RestoreState(false);
   return ret;
 }
 void CFX_QuartzDeviceDriver::setStrokeInfo(const CFX_GraphStateData* graphState,
                                            FX_ARGB argb,
                                            FX_FLOAT lineWidth) {
-  if (NULL == graphState) {
+  if (!graphState)
     return;
-  }
+
   CGContextSetLineWidth(m_context, lineWidth);
   CGLineCap cap;
   switch (graphState->m_LineCap) {
     case CFX_GraphStateData::LineCapRound: {
       cap = kCGLineCapRound;
       break;
     }
     case CFX_GraphStateData::LineCapSquare: {
       cap = kCGLineCapSquare;
       break;
@@ skipping 92 matching lines @@
         transform, CGAffineTransformMake(flip_x, 0, 0, flip_y, 0, 0));
     transform = CGAffineTransformConcat(
         transform, CGAffineTransformMake(1, 0, 0, 1, offset_x, offset_y));
     CGContextConcatCTM(m_context, transform);
     if (rect) {
       *rect = CGRectApplyAffineTransform(*rect, transform);
     }
   }
 }
 void CFX_QuartzDeviceDriver::ClearDriver() {
-  if (NULL == m_context) {
+  if (!m_context)
     return;
-  }
+
   for (int i = 0; i < m_saveCount; ++i) {
     CGContextRestoreGState(m_context);
   }
   m_saveCount = 0;
   if (m_context) {
     CGContextRelease(m_context);
   }
 }
 CFX_QuartzDevice::CFX_QuartzDevice() {
   m_bOwnedBitmap = FALSE;
-  m_pContext = NULL;
+  m_pContext = nullptr;
 }
 CFX_QuartzDevice::~CFX_QuartzDevice() {
   if (m_pContext) {
     CGContextRelease(m_pContext);
   }
   if (m_bOwnedBitmap) {
     delete GetBitmap();
   }
 }
 CGContextRef CFX_QuartzDevice::GetContext() {
   return m_pContext;
 }
 FX_BOOL CFX_QuartzDevice::Attach(CGContextRef context, int32_t nDeviceClass) {
   if (m_pContext) {
     CGContextRelease(m_pContext);
   }
   m_pContext = context;
   CGContextRetain(m_pContext);
   IFX_RenderDeviceDriver* pDriver =
       new CFX_QuartzDeviceDriver(m_pContext, nDeviceClass);
   SetDeviceDriver(pDriver);
   return TRUE;
 }
 FX_BOOL CFX_QuartzDevice::Attach(CFX_DIBitmap* pBitmap) {
   SetBitmap(pBitmap);
   m_pContext = createContextWithBitmap(pBitmap);
-  if (NULL == m_pContext) {
+  if (!m_pContext)
     return FALSE;
-  }
+
   IFX_RenderDeviceDriver* pDriver =
       new CFX_QuartzDeviceDriver(m_pContext, FXDC_DISPLAY);
   SetDeviceDriver(pDriver);
   return TRUE;
 }
 FX_BOOL CFX_QuartzDevice::Create(int32_t width,
                                  int32_t height,
                                  FXDIB_Format format) {
   if ((uint8_t)format < 32) {
     return FALSE;
   }
   CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
   if (!pBitmap->Create(width, height, format)) {
     delete pBitmap;
     return FALSE;
   }
   m_bOwnedBitmap = TRUE;
   return Attach(pBitmap);
 }
 #endif  // _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_