Style Change: NULL->nullptr

src/codec/SkCodec_libpng.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec_libpng.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
 #include "SkBitmap.h"
 #include "SkMath.h"
 #include "SkScaledCodec.h"
 #include "SkScanlineDecoder.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkSwizzler.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 // Helper macros
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef png_jmpbuf
 #  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
 #endif
 
 /* These were dropped in libpng >= 1.4 */
 #ifndef png_infopp_NULL
-    #define png_infopp_NULL NULL
+    #define png_infopp_NULL nullptr
 #endif
 
 #ifndef png_bytepp_NULL
-    #define png_bytepp_NULL NULL
+    #define png_bytepp_NULL nullptr
 #endif
 
 #ifndef int_p_NULL
-    #define int_p_NULL NULL
+    #define int_p_NULL nullptr
 #endif
 
 #ifndef png_flush_ptr_NULL
-    #define png_flush_ptr_NULL NULL
+    #define png_flush_ptr_NULL nullptr
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // Callback functions
 ///////////////////////////////////////////////////////////////////////////////
 
 static void sk_error_fn(png_structp png_ptr, png_const_charp msg) {
     SkCodecPrintf("------ png error %s\n", msg);
     longjmp(png_jmpbuf(png_ptr), 1);
 }
@@ skipping 15 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Helpers
 ///////////////////////////////////////////////////////////////////////////////
 
 class AutoCleanPng : public SkNoncopyable {
 public:
     AutoCleanPng(png_structp png_ptr)
         : fPng_ptr(png_ptr)
-        , fInfo_ptr(NULL) {}
+        , fInfo_ptr(nullptr) {}
 
     ~AutoCleanPng() {
-        // fInfo_ptr will never be non-NULL unless fPng_ptr is.
+        // fInfo_ptr will never be non-nullptr unless fPng_ptr is.
         if (fPng_ptr) {
-            png_infopp info_pp = fInfo_ptr ? &fInfo_ptr : NULL;
+            png_infopp info_pp = fInfo_ptr ? &fInfo_ptr : nullptr;
             png_destroy_read_struct(&fPng_ptr, info_pp, png_infopp_NULL);
         }
     }
 
     void setInfoPtr(png_infop info_ptr) {
-        SkASSERT(NULL == fInfo_ptr);
+        SkASSERT(nullptr == fInfo_ptr);
         fInfo_ptr = info_ptr;
     }
 
     void detach() {
-        fPng_ptr = NULL;
-        fInfo_ptr = NULL;
+        fPng_ptr = nullptr;
+        fInfo_ptr = nullptr;
     }
 
 private:
     png_structp     fPng_ptr;
     png_infop       fInfo_ptr;
 };
 #define AutoCleanPng(...) SK_REQUIRE_LOCAL_VAR(AutoCleanPng)
 
 //checks if there is transparency info in the tRNS chunk
 //image types which could have data in the tRNS chunk include: Index8, Gray8, RGB
 static bool has_transparency_in_tRNS(png_structp png_ptr,
                                         png_infop info_ptr) {
     if (!png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         return false;
     }
 
     png_bytep trans;
     int num_trans;
-    png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, NULL);
+    png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, nullptr);
     return num_trans > 0;
 }
 
 // Method for coverting to either an SkPMColor or a similarly packed
 // unpremultiplied color.
 typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
 
 // Note: SkColorTable claims to store SkPMColors, which is not necessarily
 // the case here.
 bool SkPngCodec::decodePalette(bool premultiply, int* ctableCount) {
     int numPalette;
     png_colorp palette;
     png_bytep trans;
 
     if (!png_get_PLTE(fPng_ptr, fInfo_ptr, &palette, &numPalette)) {
         return false;
     }
 
     // Note: These are not necessarily SkPMColors
     SkPMColor colorStorage[256];    // worst-case storage
     SkPMColor* colorPtr = colorStorage;
 
     int numTrans;
     if (png_get_valid(fPng_ptr, fInfo_ptr, PNG_INFO_tRNS)) {
-        png_get_tRNS(fPng_ptr, fInfo_ptr, &trans, &numTrans, NULL);
+        png_get_tRNS(fPng_ptr, fInfo_ptr, &trans, &numTrans, nullptr);
     } else {
         numTrans = 0;
     }
 
     // check for bad images that might make us crash
     if (numTrans > numPalette) {
         numTrans = numPalette;
     }
 
     int index = 0;
@@ skipping 28 matching lines @@
         addressed by the bitdepth of the image and fill it with the last palette color or black if
         the palette is empty (really broken image).
     */
     int colorCount = SkTMax(numPalette, 1 << SkTMin(fBitDepth, 8));
     SkPMColor lastColor = index > 0 ? colorPtr[-1] : SkPackARGB32(0xFF, 0, 0, 0);
     for (; index < colorCount; index++) {
         *colorPtr++ = lastColor;
     }
 
     // Set the new color count
-    if (ctableCount != NULL) {
+    if (ctableCount != nullptr) {
         *ctableCount = colorCount;
     }
 
     fColorTable.reset(new SkColorTable(colorStorage, colorCount));
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Creation
 ///////////////////////////////////////////////////////////////////////////////
 
 #define PNG_BYTES_TO_CHECK 4
 
 bool SkPngCodec::IsPng(SkStream* stream) {
     char buf[PNG_BYTES_TO_CHECK];
     if (stream->read(buf, PNG_BYTES_TO_CHECK) != PNG_BYTES_TO_CHECK) {
         return false;
     }
     if (png_sig_cmp((png_bytep) buf, (png_size_t)0, PNG_BYTES_TO_CHECK)) {
         return false;
     }
     return true;
 }
 
-// Reads the header, and initializes the passed in fields, if not NULL (except
+// Reads the header, and initializes the passed in fields, if not nullptr (except
 // stream, which is passed to the read function).
 // Returns true on success, in which case the caller is responsible for calling
 // png_destroy_read_struct. If it returns false, the passed in fields (except
 // stream) are unchanged.
 static bool read_header(SkStream* stream, png_structp* png_ptrp,
                         png_infop* info_ptrp, SkImageInfo* imageInfo, int* bitDepthPtr) {
     // The image is known to be a PNG. Decode enough to know the SkImageInfo.
-    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
+    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr,
                                                  sk_error_fn, sk_warning_fn);
     if (!png_ptr) {
         return false;
     }
 
     AutoCleanPng autoClean(png_ptr);
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
-    if (info_ptr == NULL) {
+    if (info_ptr == nullptr) {
         return false;
     }
 
     autoClean.setInfoPtr(info_ptr);
 
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(png_ptr))) {
         return false;
     }
@@ skipping 110 matching lines @@
 
 SkCodec* SkPngCodec::NewFromStream(SkStream* stream) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
     png_structp png_ptr;
     png_infop info_ptr;
     SkImageInfo imageInfo;
     int bitDepth;
     if (read_header(stream, &png_ptr, &info_ptr, &imageInfo, &bitDepth)) {
         return new SkPngCodec(imageInfo, streamDeleter.detach(), png_ptr, info_ptr, bitDepth);
     }
-    return NULL;
+    return nullptr;
 }
 
 #define INVALID_NUMBER_PASSES -1
 SkPngCodec::SkPngCodec(const SkImageInfo& info, SkStream* stream,
                        png_structp png_ptr, png_infop info_ptr, int bitDepth)
     : INHERITED(info, stream)
     , fPng_ptr(png_ptr)
     , fInfo_ptr(info_ptr)
     , fSrcConfig(SkSwizzler::kUnknown)
     , fNumberPasses(INVALID_NUMBER_PASSES)
     , fReallyHasAlpha(false)
     , fBitDepth(bitDepth)
 {}
 
 SkPngCodec::~SkPngCodec() {
     this->destroyReadStruct();
 }
 
 void SkPngCodec::destroyReadStruct() {
     if (fPng_ptr) {
-        // We will never have a NULL fInfo_ptr with a non-NULL fPng_ptr
+        // We will never have a nullptr fInfo_ptr with a non-nullptr fPng_ptr
         SkASSERT(fInfo_ptr);
         png_destroy_read_struct(&fPng_ptr, &fInfo_ptr, png_infopp_NULL);
-        fPng_ptr = NULL;
-        fInfo_ptr = NULL;
+        fPng_ptr = nullptr;
+        fInfo_ptr = nullptr;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Getting the pixels
 ///////////////////////////////////////////////////////////////////////////////
 
 SkCodec::Result SkPngCodec::initializeSwizzler(const SkImageInfo& requestedInfo,
                                                const Options& options,
                                                SkPMColor ctable[],
@@ skipping 46 matching lines @@
                     options.fZeroInitialized, this->getInfo()));
     if (!fSwizzler) {
         // FIXME: CreateSwizzler could fail for another reason.
         return kUnimplemented;
     }
     return kSuccess;
 }
 
 
 bool SkPngCodec::onRewind() {
-    // This sets fPng_ptr and fInfo_ptr to NULL. If read_header
+    // This sets fPng_ptr and fInfo_ptr to nullptr. If read_header
     // succeeds, they will be repopulated, and if it fails, they will
-    // remain NULL. Any future accesses to fPng_ptr and fInfo_ptr will
+    // remain nullptr. Any future accesses to fPng_ptr and fInfo_ptr will
     // come through this function which will rewind and again attempt
     // to reinitialize them.
     this->destroyReadStruct();
 
     png_structp png_ptr;
     png_infop info_ptr;
-    if (!read_header(this->stream(), &png_ptr, &info_ptr, NULL, NULL)) {
+    if (!read_header(this->stream(), &png_ptr, &info_ptr, nullptr, nullptr)) {
         return false;
     }
 
     fPng_ptr = png_ptr;
     fInfo_ptr = info_ptr;
     return true;
 }
 
 SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
                                         size_t dstRowBytes, const Options& options,
@@ skipping 291 matching lines @@
     // rewindIfNeeded does not have this flexibility, we need to add another
     // layer.
     bool                        fCanSkipRewind;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkPngCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkPngCodec> codec (static_cast<SkPngCodec*>(SkPngCodec::NewFromStream(stream)));
     if (!codec) {
-        return NULL;
+        return nullptr;
     }
 
     codec->fNumberPasses = png_set_interlace_handling(codec->fPng_ptr);
     SkASSERT(codec->fNumberPasses != INVALID_NUMBER_PASSES);
 
     const SkImageInfo& srcInfo = codec->getInfo();
     if (codec->fNumberPasses > 1) {
         // interlaced image
         return new SkPngInterlacedScanlineDecoder(srcInfo, codec.detach());
     }
 
     return new SkPngScanlineDecoder(srcInfo, codec.detach());
 }