Get rid of NULLs in core/

core/fxcodec/codec/fx_codec_flate.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/codec_int.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 21 matching lines @@
 static void FPDFAPI_FlateCompress(unsigned char* dest_buf,
                                   unsigned long* dest_size,
                                   const unsigned char* src_buf,
                                   unsigned long src_size) {
   compress(dest_buf, dest_size, src_buf, src_size);
 }
 void* FPDFAPI_FlateInit(void* (*alloc_func)(void*, unsigned int, unsigned int),
                         void (*free_func)(void*, void*)) {
   z_stream* p = (z_stream*)alloc_func(0, 1, sizeof(z_stream));
   if (!p) {
-    return NULL;
+    return nullptr;
   }
   FXSYS_memset(p, 0, sizeof(z_stream));
   p->zalloc = alloc_func;
   p->zfree = free_func;
   inflateInit(p);
   return p;
 }
 void FPDFAPI_FlateInput(void* context,
                         const unsigned char* src_buf,
                         unsigned int src_size) {
@@ skipping 712 matching lines @@
   uint8_t* m_pPredictRaw;
   int m_Predictor;
   int m_Colors;
   int m_BitsPerComponent;
   int m_Columns;
   uint32_t m_PredictPitch;
   size_t m_LeftOver;
 };
 
 CCodec_FlateScanlineDecoder::CCodec_FlateScanlineDecoder() {
-  m_pFlate = NULL;
-  m_pScanline = NULL;
-  m_pLastLine = NULL;
-  m_pPredictBuffer = NULL;
-  m_pPredictRaw = NULL;
+  m_pFlate = nullptr;
+  m_pScanline = nullptr;
+  m_pLastLine = nullptr;
+  m_pPredictBuffer = nullptr;
+  m_pPredictRaw = nullptr;
   m_LeftOver = 0;
 }
 CCodec_FlateScanlineDecoder::~CCodec_FlateScanlineDecoder() {
   FX_Free(m_pScanline);
   FX_Free(m_pLastLine);
   FX_Free(m_pPredictBuffer);
   FX_Free(m_pPredictRaw);
   if (m_pFlate) {
     FPDFAPI_FlateEnd(m_pFlate);
   }
@@ skipping 126 matching lines @@
                                               const uint8_t* src_buf,
                                               uint32_t src_size,
                                               FX_BOOL bEarlyChange,
                                               int predictor,
                                               int Colors,
                                               int BitsPerComponent,
                                               int Columns,
                                               uint32_t estimated_size,
                                               uint8_t*& dest_buf,
                                               uint32_t& dest_size) {
-  dest_buf = NULL;
+  dest_buf = nullptr;
   uint32_t offset = 0;
   int predictor_type = 0;
   if (predictor) {
     if (predictor >= 10) {
       predictor_type = 2;
     } else if (predictor == 2) {
       predictor_type = 1;
     }
   }
   if (bLZW) {
     {
       std::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
       dest_size = (uint32_t)-1;
       offset = src_size;
-      int err = decoder->Decode(NULL, dest_size, src_buf, offset, bEarlyChange);
+      int err =
+          decoder->Decode(nullptr, dest_size, src_buf, offset, bEarlyChange);
       if (err || dest_size == 0 || dest_size + 1 < dest_size) {
         return FX_INVALID_OFFSET;
       }
     }
     {
       std::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
       dest_buf = FX_Alloc(uint8_t, dest_size + 1);
       dest_buf[dest_size] = '\0';
       decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange);
     }
@@ skipping 17 matching lines @@
                                    uint32_t src_size,
                                    int predictor,
                                    int Colors,
                                    int BitsPerComponent,
                                    int Columns,
                                    uint8_t*& dest_buf,
                                    uint32_t& dest_size) {
   if (predictor != 2 && predictor < 10) {
     return Encode(src_buf, src_size, dest_buf, dest_size);
   }
-  uint8_t* pSrcBuf = NULL;
+  uint8_t* pSrcBuf = nullptr;

[Tom Sepez, 2016/06/02 20:09:49]

nit: combine with 981

[Lei Zhang, 2016/06/07 07:33:23]

Code is gone.

   pSrcBuf = FX_Alloc(uint8_t, src_size);
   FXSYS_memcpy(pSrcBuf, src_buf, src_size);
   FX_BOOL ret = TRUE;
   if (predictor == 2) {
     ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
                                Columns);
   } else if (predictor >= 10) {
     ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors,
                               BitsPerComponent, Columns);
   }
   if (ret)
     ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
   FX_Free(pSrcBuf);
   return ret;
 }
 FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf,
                                    uint32_t src_size,
                                    uint8_t*& dest_buf,
                                    uint32_t& dest_size) {
   dest_size = src_size + src_size / 1000 + 12;
   dest_buf = FX_Alloc(uint8_t, dest_size);
   unsigned long temp_size = dest_size;
   FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
   dest_size = (uint32_t)temp_size;
   return TRUE;
 }