Get rid of NULLs in core/

core/fxcodec/codec/fx_codec_progress.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/fxcodec/codec/include/ccodec_progressivedecoder.h"
 
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxge/include/fx_dib.h"
@@ skipping 21 matching lines @@
   if (dest_len < 0) {
     base = (FX_FLOAT)(src_len);
   } else {
     base = 0.0f;
   }
   m_ItemSize =
       (int)(sizeof(int) * 2 +
             sizeof(int) * (FXSYS_ceil(FXSYS_fabs((FX_FLOAT)scale)) + 1));
   m_DestMin = dest_min;
   m_pWeightTables = FX_Alloc(uint8_t, (dest_max - dest_min) * m_ItemSize + 4);
-  if (m_pWeightTables == NULL) {
-    return;
-  }
   if (FXSYS_fabs((FX_FLOAT)scale) < 1.0f) {
     for (int dest_pixel = dest_min; dest_pixel < dest_max; dest_pixel++) {
       PixelWeight& pixel_weights = *GetPixelWeight(dest_pixel);
       double src_pos = dest_pixel * scale + scale / 2 + base;
       if (bInterpol) {
         pixel_weights.m_SrcStart =
             (int)FXSYS_floor((FX_FLOAT)src_pos - 1.0f / 2);
         pixel_weights.m_SrcEnd = (int)FXSYS_floor((FX_FLOAT)src_pos + 1.0f / 2);
         if (pixel_weights.m_SrcStart < src_min) {
           pixel_weights.m_SrcStart = src_min;
@@ skipping 69 matching lines @@
 void CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::Calc(int dest_len,
                                                          int src_len,
                                                          FX_BOOL bInterpol) {
   if (m_pWeightTables) {
     FX_Free(m_pWeightTables);
   }
   double scale = (double)dest_len / (double)src_len;
   m_ItemSize = sizeof(int) * 4;
   int size = dest_len * m_ItemSize + 4;
   m_pWeightTables = FX_Alloc(uint8_t, size);
-  if (m_pWeightTables == NULL) {
-    return;
-  }
   FXSYS_memset(m_pWeightTables, 0, size);
   if (scale > 1) {
     int pre_des_col = 0;
     for (int src_col = 0; src_col < src_len; src_col++) {
       double des_col_f = src_col * scale;
       int des_col = FXSYS_round((FX_FLOAT)des_col_f);
       PixelWeight* pWeight =
           (PixelWeight*)(m_pWeightTables + des_col * m_ItemSize);
       pWeight->m_SrcStart = pWeight->m_SrcEnd = src_col;
       pWeight->m_Weights[0] = 65536;
@@ skipping 38 matching lines @@
 }
 void CCodec_ProgressiveDecoder::CFXCODEC_VertTable::Calc(int dest_len,
                                                          int src_len) {
   if (m_pWeightTables) {
     FX_Free(m_pWeightTables);
   }
   double scale = (double)dest_len / (double)src_len;
   m_ItemSize = sizeof(int) * 4;
   int size = dest_len * m_ItemSize + 4;
   m_pWeightTables = FX_Alloc(uint8_t, size);
-  if (m_pWeightTables == NULL) {
-    return;
-  }
   FXSYS_memset(m_pWeightTables, 0, size);
   if (scale > 1) {
     double step = 0.0;
     int src_row = 0;
     while (step < (double)dest_len) {
       int start_step = (int)step;
       step = scale * (++src_row);
       int end_step = (int)step;
       if (end_step >= dest_len) {
         end_step = dest_len;
@@ skipping 134 matching lines @@
   return TRUE;
 }
 FX_BOOL CCodec_ProgressiveDecoder::PngReadHeaderFunc(void* pModule,
                                                      int width,
                                                      int height,
                                                      int bpc,
                                                      int pass,
                                                      int* color_type,
                                                      double* gamma) {
   CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
-  if (pCodec->m_pDeviceBitmap == NULL) {
+  if (!pCodec->m_pDeviceBitmap) {
     pCodec->m_SrcWidth = width;
     pCodec->m_SrcHeight = height;
     pCodec->m_SrcBPC = bpc;
     pCodec->m_SrcPassNumber = pass;
     pCodec->m_SrcComponents =
         *color_type == 0 ? 1 : *color_type == 2
                                    ? 3
                                    : *color_type == 3
                                          ? 4
                                          : *color_type == 4
@@ skipping 268 matching lines @@
                                error_status)) {
     return FALSE;
   }
   uint8_t* pPalette = NULL;
   if (pal_num != 0 && pal_ptr) {
     pPalette = (uint8_t*)pal_ptr;
   } else {
     pal_num = pCodec->m_GifPltNumber;
     pPalette = pCodec->m_pGifPalette;
   }
-  if (pCodec->m_pSrcPalette == NULL) {
+  if (!pCodec->m_pSrcPalette) {
     pCodec->m_pSrcPalette = FX_Alloc(FX_ARGB, pal_num);
   } else if (pal_num > pCodec->m_SrcPaletteNumber) {
     pCodec->m_pSrcPalette = FX_Realloc(FX_ARGB, pCodec->m_pSrcPalette, pal_num);
   }
-  if (pCodec->m_pSrcPalette == NULL) {
+  if (!pCodec->m_pSrcPalette)
     return FALSE;
-  }
+
   pCodec->m_SrcPaletteNumber = pal_num;
   for (int i = 0; i < pal_num; i++) {
     uint32_t j = i * 3;
     pCodec->m_pSrcPalette[i] =
         ArgbEncode(0xff, pPalette[j], pPalette[j + 1], pPalette[j + 2]);
   }
   pCodec->m_GifTransIndex = trans_index;
   pCodec->m_GifFrameRect = img_rc;
   pCodec->m_SrcPassNumber = interlace ? 4 : 1;
   int32_t pal_index = pCodec->m_GifBgIndex;
@@ skipping 354 matching lines @@
   if (size > FXCODEC_BLOCK_SIZE) {
     size = FXCODEC_BLOCK_SIZE;
   }
   FX_Free(m_pSrcBuf);
   m_pSrcBuf = FX_Alloc(uint8_t, size);
   FXSYS_memset(m_pSrcBuf, 0, size);
   m_SrcSize = size;
   switch (imageType) {
     case FXCODEC_IMAGE_BMP: {
       CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
-      if (pBmpModule == NULL) {
+      if (!pBmpModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pBmpModule->InputImagePositionBufCallback =
           BmpInputImagePositionBufCallback;
       pBmpModule->ReadScanlineCallback = BmpReadScanlineCallback;
       m_pBmpContext = pBmpModule->Start((void*)this);
-      if (m_pBmpContext == NULL) {
+      if (!m_pBmpContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       pBmpModule->Input(m_pBmpContext, m_pSrcBuf, size);
@@ skipping 26 matching lines @@
       }
       if (m_pBmpContext) {
         pBmpModule->Finish(m_pBmpContext);
         m_pBmpContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_JPG: {
       CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
-      if (pJpegModule == NULL) {
+      if (!pJpegModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       m_pJpegContext = pJpegModule->Start();
-      if (m_pJpegContext == NULL) {
+      if (!m_pJpegContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       pJpegModule->Input(m_pJpegContext, m_pSrcBuf, size);
@@ skipping 17 matching lines @@
       }
       if (m_pJpegContext) {
         pJpegModule->Finish(m_pJpegContext);
         m_pJpegContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_PNG: {
       CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
-      if (pPngModule == NULL) {
+      if (!pPngModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pPngModule->ReadHeaderCallback =
           CCodec_ProgressiveDecoder::PngReadHeaderFunc;
       pPngModule->AskScanlineBufCallback =
           CCodec_ProgressiveDecoder::PngAskScanlineBufFunc;
       pPngModule->FillScanlineBufCompletedCallback =
           CCodec_ProgressiveDecoder::PngFillScanlineBufCompletedFunc;
       m_pPngContext = pPngModule->Start((void*)this);
-      if (m_pPngContext == NULL) {
+      if (!m_pPngContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       bResult = pPngModule->Input(m_pPngContext, m_pSrcBuf, size, pAttribute);
@@ skipping 29 matching lines @@
         pPngModule->Finish(m_pPngContext);
         m_pPngContext = NULL;
       }
       if (m_SrcPassNumber == 0) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
     } break;
     case FXCODEC_IMAGE_GIF: {
       CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
-      if (pGifModule == NULL) {
+      if (!pGifModule) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pGifModule->RecordCurrentPositionCallback =
           CCodec_ProgressiveDecoder::GifRecordCurrentPositionCallback;
       pGifModule->AskLocalPaletteBufCallback =
           CCodec_ProgressiveDecoder::GifAskLocalPaletteBufCallback;
       pGifModule->InputRecordPositionBufCallback =
           CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback;
       pGifModule->ReadScanlineCallback =
           CCodec_ProgressiveDecoder::GifReadScanlineCallback;
       m_pGifContext = pGifModule->Start((void*)this);
-      if (m_pGifContext == NULL) {
+      if (!m_pGifContext) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
       if (!bResult) {
         m_status = FXCODEC_STATUS_ERR_READ;
         return FALSE;
       }
       m_offSet += size;
       pGifModule->Input(m_pGifContext, m_pSrcBuf, size);
@@ skipping 18 matching lines @@
       }
       if (m_pGifContext) {
         pGifModule->Finish(m_pGifContext);
         m_pGifContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_TIF: {
       CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
-      if (pTiffModule == NULL) {
+      if (!pTiffModule) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
       m_pTiffContext = pTiffModule->CreateDecoder(m_pFile);
-      if (m_pTiffContext == NULL) {
+      if (!m_pTiffContext) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
       int32_t frames = 0;
       pTiffModule->GetFrames(m_pTiffContext, frames);
       uint32_t bpc;
       FX_BOOL ret = pTiffModule->LoadFrameInfo(
           m_pTiffContext, 0, (uint32_t&)m_SrcWidth, (uint32_t&)m_SrcHeight,
           (uint32_t&)m_SrcComponents, bpc, pAttribute);
       m_SrcComponents = 4;
@@ skipping 17 matching lines @@
     CFX_DIBAttribute* pAttribute) {
   switch (m_status) {
     case FXCODEC_STATUS_FRAME_READY:
     case FXCODEC_STATUS_FRAME_TOBECONTINUE:
     case FXCODEC_STATUS_DECODE_READY:
     case FXCODEC_STATUS_DECODE_TOBECONTINUE:
       return FXCODEC_STATUS_ERROR;
     default:
       break;
   }
-  if (pFile == NULL) {
+  if (!pFile) {
     m_status = FXCODEC_STATUS_ERR_PARAMS;
     m_pFile = NULL;
     return m_status;
   }
   m_pFile = pFile;
   m_offSet = 0;
   m_SrcWidth = m_SrcHeight = 0;
   m_SrcComponents = m_SrcBPC = 0;
   m_clipBox = FX_RECT(0, 0, 0, 0);
   m_startX = m_startY = 0;
@@ skipping 552 matching lines @@
   }
   return FXCODEC_STATUS_ERROR;
 }
 FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
                                                       int start_x,
                                                       int start_y,
                                                       int size_x,
                                                       int size_y,
                                                       int32_t frames,
                                                       FX_BOOL bInterpol) {
-  if (m_status != FXCODEC_STATUS_DECODE_READY) {
+  if (m_status != FXCODEC_STATUS_DECODE_READY)
     return FXCODEC_STATUS_ERROR;
-  }
-  if (pDIBitmap == NULL || pDIBitmap->GetBPP() < 8 || frames < 0 ||
+
+  if (!pDIBitmap || pDIBitmap->GetBPP() < 8 || frames < 0 ||
       frames >= m_FrameNumber) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
   m_pDeviceBitmap = pDIBitmap;
   if (m_clipBox.IsEmpty()) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
   if (size_x <= 0 || size_x > 65535 || size_y <= 0 || size_y > 65535) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
@@ skipping 65 matching lines @@
           break;
         case 4:
           m_SrcFormat = FXCodec_Cmyk;
           break;
       }
       GetTransMethod(pDIBitmap->GetFormat(), m_SrcFormat);
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_PNG: {
       CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
-      if (pPngModule == NULL) {
+      if (!pPngModule) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       if (m_pPngContext) {
         pPngModule->Finish(m_pPngContext);
         m_pPngContext = NULL;
       }
       m_pPngContext = pPngModule->Start((void*)this);
-      if (m_pPngContext == NULL) {
+      if (!m_pPngContext) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       m_offSet = 0;
       switch (m_pDeviceBitmap->GetFormat()) {
         case FXDIB_8bppMask:
         case FXDIB_8bppRgb:
           m_SrcComponents = 1;
           m_SrcFormat = FXCodec_8bppGray;
@@ skipping 17 matching lines @@
       int scanline_size = (m_SrcWidth * m_SrcComponents + 3) / 4 * 4;
       FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
       FXSYS_memset(m_pDecodeBuf, 0, scanline_size);
       m_WeightHorzOO.Calc(m_sizeX, m_clipBox.Width(), m_bInterpol);
       m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_GIF: {
       CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
-      if (pGifModule == NULL) {
+      if (!pGifModule) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       m_SrcFormat = FXCodec_8bppRgb;
       GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
       int scanline_size = (m_SrcWidth + 3) / 4 * 4;
       FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
       FXSYS_memset(m_pDecodeBuf, 0, scanline_size);
       m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0,
                         m_clipBox.Width(), m_bInterpol);
       m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
       m_FrameCur = frames;
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_BMP: {
       CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
-      if (pBmpModule == NULL) {
+      if (!pBmpModule) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       switch (m_SrcComponents) {
         case 1:
           m_SrcFormat = FXCodec_8bppRgb;
           break;
         case 3:
           m_SrcFormat = FXCodec_Rgb;
@@ skipping 159 matching lines @@
         ret = pTiffModule->Decode(m_pTiffContext, m_pDeviceBitmap);
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         if (!ret) {
           return m_status = FXCODEC_STATUS_ERROR;
         }
         return m_status = FXCODEC_STATUS_DECODE_FINISH;
       } else {
         CFX_DIBitmap* pDIBitmap = new CFX_DIBitmap;
         pDIBitmap->Create(m_SrcWidth, m_SrcHeight, FXDIB_Argb);
-        if (pDIBitmap->GetBuffer() == NULL) {
+        if (!pDIBitmap->GetBuffer()) {
           delete pDIBitmap;
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_ERR_MEMORY;
         }
         ret = pTiffModule->Decode(m_pTiffContext, pDIBitmap);
         if (!ret) {
           delete pDIBitmap;
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_ERROR;
         }
         CFX_DIBitmap* pClipBitmap =
             (m_clipBox.left == 0 && m_clipBox.top == 0 &&
              m_clipBox.right == m_SrcWidth && m_clipBox.bottom == m_SrcHeight)
                 ? pDIBitmap
                 : pDIBitmap->Clone(&m_clipBox);
         if (pDIBitmap != pClipBitmap) {
           delete pDIBitmap;
         }
-        if (pClipBitmap == NULL) {
+        if (!pClipBitmap) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_ERR_MEMORY;
         }
         CFX_DIBitmap* pFormatBitmap = NULL;
         switch (m_pDeviceBitmap->GetFormat()) {
           case FXDIB_8bppRgb:
             pFormatBitmap = new CFX_DIBitmap;
             pFormatBitmap->Create(pClipBitmap->GetWidth(),
                                   pClipBitmap->GetHeight(), FXDIB_8bppRgb);
@@ skipping 54 matching lines @@
                 src_line += 4;
               }
             }
           } break;
           default:
             break;
         }
         if (pClipBitmap != pFormatBitmap) {
           delete pClipBitmap;
         }
-        if (pFormatBitmap == NULL) {
+        if (!pFormatBitmap) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_ERR_MEMORY;
         }
         CFX_DIBitmap* pStrechBitmap = pFormatBitmap->StretchTo(
             m_sizeX, m_sizeY, m_bInterpol ? FXDIB_INTERPOL : FXDIB_DOWNSAMPLE);
         delete pFormatBitmap;
         pFormatBitmap = NULL;
-        if (pStrechBitmap == NULL) {
+        if (!pStrechBitmap) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_ERR_MEMORY;
         }
         m_pDeviceBitmap->TransferBitmap(m_startX, m_startY, m_sizeX, m_sizeY,
                                         pStrechBitmap, 0, 0);
         delete pStrechBitmap;
         pStrechBitmap = NULL;
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_DECODE_FINISH;
       }
     } break;
     default:
       break;
   }
   return FXCODEC_STATUS_ERROR;
 }
 CCodec_ProgressiveDecoder* CCodec_ModuleMgr::CreateProgressiveDecoder() {
   return new CCodec_ProgressiveDecoder(this);
 }