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

core/src/fxge/agg/src/fx_agg_driver.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/src/fxge/agg/include/fx_agg_driver.h"
 
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_ge.h"
@@ skipping 132 matching lines @@
   }
   FX_FLOAT width = pGraphState->m_LineWidth * scale;
   FX_FLOAT unit = 1.f;
   if (pObject2Device) {
     unit = FXSYS_Div(
         1.0f, (pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2);
   }
   if (width < unit) {
     width = unit;
   }
-  if (pGraphState->m_DashArray == NULL) {
-    agg::conv_stroke<agg::path_storage> stroke(path_data);
-    stroke.line_join(join);
-    stroke.line_cap(cap);
-    stroke.miter_limit(pGraphState->m_MiterLimit);
-    stroke.width(width);
-    rasterizer.add_path_transformed(stroke, pObject2Device);
-  } else {
+  if (pGraphState->m_DashArray) {
     typedef agg::conv_dash<agg::path_storage> dash_converter;
     dash_converter dash(path_data);
     for (int i = 0; i < (pGraphState->m_DashCount + 1) / 2; i++) {
       FX_FLOAT on = pGraphState->m_DashArray[i * 2];
       if (on <= 0.000001f) {
         on = 1.0f / 10;
       }
       FX_FLOAT off = i * 2 + 1 == pGraphState->m_DashCount
                          ? on
                          : pGraphState->m_DashArray[i * 2 + 1];
       if (off < 0) {
         off = 0;
       }
       dash.add_dash(on * scale, off * scale);
     }
     dash.dash_start(pGraphState->m_DashPhase * scale);
     typedef agg::conv_stroke<dash_converter> dash_stroke;
     dash_stroke stroke(dash);
     stroke.line_join(join);
     stroke.line_cap(cap);
     stroke.miter_limit(pGraphState->m_MiterLimit);
     stroke.width(width);
     rasterizer.add_path_transformed(stroke, pObject2Device);
+  } else {
+    agg::conv_stroke<agg::path_storage> stroke(path_data);
+    stroke.line_join(join);
+    stroke.line_cap(cap);
+    stroke.miter_limit(pGraphState->m_MiterLimit);
+    stroke.width(width);
+    rasterizer.add_path_transformed(stroke, pObject2Device);
   }
 }
 IFX_RenderDeviceDriver* IFX_RenderDeviceDriver::CreateFxgeDriver(
     CFX_DIBitmap* pBitmap,
     FX_BOOL bRgbByteOrder,
     CFX_DIBitmap* pOriDevice,
     FX_BOOL bGroupKnockout) {
   return new CFX_AggDeviceDriver(pBitmap, 0, bRgbByteOrder, pOriDevice,
                                  bGroupKnockout);
 }
@@ skipping 353 matching lines @@
         if (m_bFullCover) {
           *dest_scan = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
         } else {
           int gray = FXDIB_ALPHA_MERGE(*ori_scan++, m_Gray, src_alpha);
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, cover_scan[col]);
           dest_scan++;
         }
       }
     } else {
       int index = 0;
-      if (m_pDevice->GetPalette() == NULL) {
-        index = ((uint8_t)m_Color == 0xff) ? 1 : 0;
-      } else {
-        for (int i = 0; i < 2; i++)
+      if (m_pDevice->GetPalette()) {
+        for (int i = 0; i < 2; i++) {
           if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) {
             index = i;
           }
+        }
+      } else {
+        index = ((uint8_t)m_Color == 0xff) ? 1 : 0;
       }
       uint8_t* dest_scan1 = dest_scan;
       for (int col = col_start; col < col_end; col++) {
         int src_alpha;
         if (clip_scan) {
           src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
         } else {
           src_alpha = m_Alpha * cover_scan[col] / 255;
         }
         if (src_alpha) {
@@ skipping 17 matching lines @@
                          uint8_t* clip_scan,
                          uint8_t* dest_extra_alpha_scan) {
     ASSERT(!m_bRgbByteOrder);
     ASSERT(!m_pDevice->IsCmykImage());
     int col_start = span_left < clip_left ? clip_left - span_left : 0;
     int col_end = (span_left + span_len) < clip_right
                       ? span_len
                       : (clip_right - span_left);
     dest_scan += col_start / 8;
     int index = 0;
-    if (m_pDevice->GetPalette() == NULL) {
-      index = ((uint8_t)m_Color == 0xff) ? 1 : 0;
-    } else {
-      for (int i = 0; i < 2; i++)
+    if (m_pDevice->GetPalette()) {
+      for (int i = 0; i < 2; i++) {
         if (FXARGB_TODIB(m_pDevice->GetPalette()[i]) == m_Color) {
           index = i;
         }
+      }
+    } else {
+      index = ((uint8_t)m_Color == 0xff) ? 1 : 0;
     }
     uint8_t* dest_scan1 = dest_scan;
     for (int col = col_start; col < col_end; col++) {
       int src_alpha;
       if (clip_scan) {
         src_alpha = m_Alpha * cover_scan[col] * clip_scan[col] / 255 / 255;
       } else {
         src_alpha = m_Alpha * cover_scan[col] / 255;
       }
       if (src_alpha) {
@@ skipping 369 matching lines @@
             dest_scan++;
             continue;
           }
         }
         dest_scan += 4;
       }
     }
   }
   template <class Scanline>
   void render(const Scanline& sl) {
-    if (m_pOriDevice == NULL && composite_span == NULL) {
+    if (!m_pOriDevice && !composite_span) {
       return;
     }
     int y = sl.y();
     if (y < m_ClipBox.top || y >= m_ClipBox.bottom) {
       return;
     }
     uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * y;
     uint8_t* dest_scan_extra_alpha = NULL;
     CFX_DIBitmap* pAlphaMask = m_pDevice->m_pAlphaMask;
     if (pAlphaMask) {
@@ skipping 197 matching lines @@
                                       const CFX_GraphStateData* pGraphState,
                                       FX_DWORD fill_color,
                                       FX_DWORD stroke_color,
                                       int fill_mode,
                                       int alpha_flag,
                                       void* pIccTransform,
                                       int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
-  if (GetBuffer() == NULL) {
+  if (!GetBuffer()) {
     return TRUE;
   }
   m_FillFlags = fill_mode;
   if ((fill_mode & 3) && fill_color) {
     CAgg_PathData path_data;
     path_data.BuildPath(pPathData, pObject2Device);
     agg::rasterizer_scanline_aa rasterizer;
     rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                         (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
     rasterizer.add_path(path_data.m_PathData);
@@ skipping 153 matching lines @@
   }
 }
 void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap,
                                 int dest_left,
                                 int dest_top,
                                 int width,
                                 int height,
                                 const CFX_DIBSource* pSrcBitmap,
                                 int src_left,
                                 int src_top) {
-  if (pBitmap == NULL) {
+  if (!pBitmap) {
     return;
   }
   pBitmap->GetOverlapRect(dest_left, dest_top, width, height,
                           pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(),
                           src_left, src_top, NULL);
   if (width == 0 || height == 0) {
     return;
   }
   int Bpp = pBitmap->GetBPP() / 8;
   FXDIB_Format dest_format = pBitmap->GetFormat();
@@ skipping 120 matching lines @@
   if (pDevice->m_pAlphaMask) {
     pDevice->m_pAlphaMask->SetPixel(x, y, alpha << 24);
   }
   return TRUE;
 }
 FX_BOOL CFX_AggDeviceDriver::SetPixel(int x,
                                       int y,
                                       FX_DWORD color,
                                       int alpha_flag,
                                       void* pIccTransform) {
-  if (m_pBitmap->GetBuffer() == NULL) {
+  if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
     pIccTransform = NULL;
   }
-  if (m_pClipRgn == NULL) {
+  if (!m_pClipRgn) {
     if (m_bRgbByteOrder) {
       RgbByteOrderSetPixel(m_pBitmap, x, y, color);
     } else {
       return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform);
     }
   } else if (m_pClipRgn->GetBox().Contains(x, y)) {
     if (m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
       if (m_bRgbByteOrder) {
         RgbByteOrderSetPixel(m_pBitmap, x, y, color);
       } else {
@@ skipping 21 matching lines @@
   return TRUE;
 }
 FX_BOOL CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect,
                                       FX_DWORD fill_color,
                                       int alpha_flag,
                                       void* pIccTransform,
                                       int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
-  if (m_pBitmap->GetBuffer() == NULL) {
+  if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   FX_RECT clip_rect;
   GetClipBox(&clip_rect);
   FX_RECT draw_rect = clip_rect;
   if (pRect) {
     draw_rect.Intersect(*pRect);
   }
   if (draw_rect.IsEmpty()) {
     return TRUE;
   }
-  if (m_pClipRgn == NULL || m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
+  if (!m_pClipRgn || m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
     if (m_bRgbByteOrder) {
       RgbByteOrderCompositeRect(m_pBitmap, draw_rect.left, draw_rect.top,
                                 draw_rect.Width(), draw_rect.Height(),
                                 fill_color);
     } else {
       m_pBitmap->CompositeRect(draw_rect.left, draw_rect.top, draw_rect.Width(),
                                draw_rect.Height(), fill_color, alpha_flag,
                                pIccTransform);
     }
     return TRUE;
   }
   m_pBitmap->CompositeMask(
       draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(),
       (const CFX_DIBitmap*)m_pClipRgn->GetMask(), fill_color,
       draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top,
       FXDIB_BLEND_NORMAL, NULL, m_bRgbByteOrder, alpha_flag, pIccTransform);
   return TRUE;
 }
 FX_BOOL CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect) {
-  if (m_pClipRgn == NULL) {
+  if (!m_pClipRgn) {
     pRect->left = pRect->top = 0;
     pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH);
     pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT);
     return TRUE;
   }
   *pRect = m_pClipRgn->GetBox();
   return TRUE;
 }
 FX_BOOL CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap,
                                        int left,
                                        int top,
                                        void* pIccTransform,
                                        FX_BOOL bDEdge) {
-  if (m_pBitmap->GetBuffer() == NULL) {
+  if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (bDEdge) {
     if (m_bRgbByteOrder) {
       RgbByteOrderTransferBitmap(pBitmap, 0, 0, pBitmap->GetWidth(),
                                  pBitmap->GetHeight(), m_pBitmap, left, top);
     } else {
       return pBitmap->TransferBitmap(0, 0, pBitmap->GetWidth(),
                                      pBitmap->GetHeight(), m_pBitmap, left, top,
                                      pIccTransform);
@@ skipping 30 matching lines @@
   return bRet;
 }
 FX_BOOL CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
                                        FX_DWORD argb,
                                        const FX_RECT* pSrcRect,
                                        int left,
                                        int top,
                                        int blend_type,
                                        int alpha_flag,
                                        void* pIccTransform) {
-  if (m_pBitmap->GetBuffer() == NULL) {
+  if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (pBitmap->IsAlphaMask())
     return m_pBitmap->CompositeMask(
         left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
         pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder,
         alpha_flag, pIccTransform);
   return m_pBitmap->CompositeBitmap(
       left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, pSrcRect->left,
       pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, pIccTransform);
 }
 FX_BOOL CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
                                            FX_DWORD argb,
                                            int dest_left,
                                            int dest_top,
                                            int dest_width,
                                            int dest_height,
                                            const FX_RECT* pClipRect,
                                            FX_DWORD flags,
                                            int alpha_flag,
                                            void* pIccTransform,
                                            int blend_type) {
-  if (m_pBitmap->GetBuffer() == NULL) {
+  if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (dest_width == pSource->GetWidth() &&
       dest_height == pSource->GetHeight()) {
     FX_RECT rect(0, 0, dest_width, dest_height);
     return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type,
                      alpha_flag, pIccTransform);
   }
   FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width,
                     dest_top + dest_height);
@@ skipping 14 matching lines @@
 }
 FX_BOOL CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
                                          int bitmap_alpha,
                                          FX_DWORD argb,
                                          const CFX_Matrix* pMatrix,
                                          FX_DWORD render_flags,
                                          void*& handle,
                                          int alpha_flag,
                                          void* pIccTransform,
                                          int blend_type) {
-  if (m_pBitmap->GetBuffer() == NULL) {
+  if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer;
   pRenderer->Start(m_pBitmap, m_pClipRgn, pSource, bitmap_alpha, argb, pMatrix,
                    render_flags, m_bRgbByteOrder, alpha_flag, pIccTransform);
   handle = pRenderer;
   return TRUE;
 }
 FX_BOOL CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
-  if (m_pBitmap->GetBuffer() == NULL) {
+  if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   return ((CFX_ImageRenderer*)pHandle)->Continue(pPause);
 }
 void CFX_AggDeviceDriver::CancelDIBits(void* pHandle) {
-  if (m_pBitmap->GetBuffer() == NULL) {
+  if (!m_pBitmap->GetBuffer()) {
     return;
   }
   delete (CFX_ImageRenderer*)pHandle;
 }
 CFX_FxgeDevice::CFX_FxgeDevice() {
   m_bOwnedBitmap = FALSE;
 }
 FX_BOOL CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap,
                                int dither_bits,
                                FX_BOOL bRgbByteOrder,
                                CFX_DIBitmap* pOriDevice,
                                FX_BOOL bGroupKnockout) {
-  if (pBitmap == NULL) {
+  if (!pBitmap) {
     return FALSE;
   }
   SetBitmap(pBitmap);
   IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver(
       pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
   SetDeviceDriver(pDriver);
   return TRUE;
 }
 FX_BOOL CFX_FxgeDevice::Create(int width,
                                int height,
@@ skipping 10 matching lines @@
   IFX_RenderDeviceDriver* pDriver =
       new CFX_AggDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
   SetDeviceDriver(pDriver);
   return TRUE;
 }
 CFX_FxgeDevice::~CFX_FxgeDevice() {
   if (m_bOwnedBitmap) {
     delete GetBitmap();
   }
 }