Style Change: NULL->nullptr

src/codec/SkCodec_libgif.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_libgif.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 41 matching lines @@
 static int32_t read_bytes_callback(GifFileType* fileType, GifByteType* out,
         int32_t size) {
     SkStream* stream = (SkStream*) fileType->UserData;
     return (int32_t) stream->read(out, size);
 }
 
 /*
  * Open the gif file
  */
 static GifFileType* open_gif(SkStream* stream) {
-    return DGifOpen(stream, read_bytes_callback, NULL);
+    return DGifOpen(stream, read_bytes_callback, nullptr);
 }
 
  /*
  * This function cleans up the gif object after the decode completes
  * It is used in a SkAutoTCallIProc template
  */
 void SkGifCodec::CloseGif(GifFileType* gif) {
-    DGifCloseFile(gif, NULL);
+    DGifCloseFile(gif, nullptr);
 }
 
 /*
  * This function free extension data that has been saved to assist the image
  * decoder
  */
 void SkGifCodec::FreeExtension(SavedImage* image) {
-    if (NULL != image->ExtensionBlocks) {
+    if (nullptr != image->ExtensionBlocks) {
         GifFreeExtensions(&image->ExtensionBlockCount, &image->ExtensionBlocks);
     }
 }
 
 /*
  * Check if a there is an index of the color table for a transparent pixel
  */
 static uint32_t find_trans_index(const SavedImage& image) {
     // If there is a transparent index specified, it will be contained in an
     // extension block.  We will loop through extension blocks in reverse order
@@ skipping 27 matching lines @@
     // Use maximum unsigned int (surely an invalid index) to indicate that a valid
     // index was not found.
     return SK_MaxU32;
 }
 
 /*
  * Read enough of the stream to initialize the SkGifCodec.
  * Returns a bool representing success or failure.
  *
  * @param codecOut
- * If it returned true, and codecOut was not NULL,
+ * If it returned true, and codecOut was not nullptr,
  * codecOut will be set to a new SkGifCodec.
  *
  * @param gifOut
- * If it returned true, and codecOut was NULL,
- * gifOut must be non-NULL and gifOut will be set to a new
+ * If it returned true, and codecOut was nullptr,
+ * gifOut must be non-nullptr and gifOut will be set to a new
  * GifFileType pointer.
  *
  * @param stream
  * Deleted on failure.
  * codecOut will take ownership of it in the case where we created a codec.
  * Ownership is unchanged when we returned a gifOut.
  *
  */
 bool SkGifCodec::ReadHeader(SkStream* stream, SkCodec** codecOut, GifFileType** gifOut) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
 
     // Read gif header, logical screen descriptor, and global color table
     SkAutoTCallVProc<GifFileType, CloseGif> gif(open_gif(stream));
 
-    if (NULL == gif) {
+    if (nullptr == gif) {
         gif_error("DGifOpen failed.\n");
         return false;
     }
 
-    if (NULL != codecOut) {
+    if (nullptr != codecOut) {
         // Get fields from header
         const int32_t width = gif->SWidth;
         const int32_t height = gif->SHeight;
         if (width <= 0 || height <= 0) {
             gif_error("Invalid dimensions.\n");
             return false;
         }
 
         // Return the codec
         // kIndex is the most natural color type for gifs, so we set this as
         // the default.
         // Many gifs specify a color table index for transparent pixels.  Every
         // other pixel is guaranteed to be opaque.  Despite this, because of the
         // possiblity of transparent pixels, we cannot assume that the image is
         // opaque.  We have the option to set the alpha type as kPremul or
         // kUnpremul.  Both are valid since the alpha component will always be
         // 0xFF or the entire 32-bit pixel will be set to zero.  We prefer
         // kPremul because we support kPremul, and it is more efficient to
         // use kPremul directly even when kUnpremul is supported.
         const SkImageInfo& imageInfo = SkImageInfo::Make(width, height,
                 kIndex_8_SkColorType, kPremul_SkAlphaType);
         *codecOut = new SkGifCodec(imageInfo, streamDeleter.detach(), gif.detach());
     } else {
-        SkASSERT(NULL != gifOut);
+        SkASSERT(nullptr != gifOut);
         streamDeleter.detach();
         *gifOut = gif.detach();
     }
     return true;
 }
 
 /*
  * Assumes IsGif was called and returned true
  * Creates a gif decoder
  * Reads enough of the stream to determine the image format
  */
 SkCodec* SkGifCodec::NewFromStream(SkStream* stream) {
-    SkCodec* codec = NULL;
-    if (ReadHeader(stream, &codec, NULL)) {
+    SkCodec* codec = nullptr;
+    if (ReadHeader(stream, &codec, nullptr)) {
         return codec;
     }
-    return NULL;
+    return nullptr;
 }
 
 SkGifCodec::SkGifCodec(const SkImageInfo& srcInfo, SkStream* stream,
                        GifFileType* gif)
     : INHERITED(srcInfo, stream)
     , fGif(gif)
 {}
 
 bool SkGifCodec::onRewind() {
-    GifFileType* gifOut = NULL;
-    if (!ReadHeader(this->stream(), NULL, &gifOut)) {
+    GifFileType* gifOut = nullptr;
+    if (!ReadHeader(this->stream(), nullptr, &gifOut)) {
         return false;
     }
 
-    SkASSERT(NULL != gifOut);
+    SkASSERT(nullptr != gifOut);
     fGif.reset(gifOut);
     return true;
 }
 
 /*
  * Initiates the gif decode
  */
 SkCodec::Result SkGifCodec::onGetPixels(const SkImageInfo& dstInfo,
                                         void* dst, size_t dstRowBytes,
                                         const Options& opts,
@@ skipping 14 matching lines @@
     }
     if (!conversion_possible(dstInfo, this->getInfo())) {
         return gif_error("Cannot convert input type to output type.\n",
                 kInvalidConversion);
     }
 
     // Use this as a container to hold information about any gif extension
     // blocks.  This generally stores transparency and animation instructions.
     SavedImage saveExt;
     SkAutoTCallVProc<SavedImage, FreeExtension> autoFreeExt(&saveExt);
-    saveExt.ExtensionBlocks = NULL;
+    saveExt.ExtensionBlocks = nullptr;
     saveExt.ExtensionBlockCount = 0;
     GifByteType* extData;
     int32_t extFunction;
 
     // We will loop over components of gif images until we find an image.  Once
     // we find an image, we will decode and return it.  While many gif files
     // contain more than one image, we will simply decode the first image.
     const int32_t width = dstInfo.width();
     const int32_t height = dstInfo.height();
     GifRecordType recordType;
@@ skipping 49 matching lines @@
                 } else if (imageTop < 0) {
                     gif_warning("Shifting image down to fit\n");
                     imageTop = 0;
                 }
 
                 // Create a color table to store colors the giflib colorMap
                 SkPMColor alternateColorPtr[256];
                 SkPMColor* colorTable;
                 SkColorType dstColorType = dstInfo.colorType();
                 if (kIndex_8_SkColorType == dstColorType) {
-                    SkASSERT(NULL != inputColorPtr);
-                    SkASSERT(NULL != inputColorCount);
+                    SkASSERT(nullptr != inputColorPtr);
+                    SkASSERT(nullptr != inputColorCount);
                     colorTable = inputColorPtr;
                 } else {
                     colorTable = alternateColorPtr;
                 }
 
                 // Set up the color table
                 uint32_t colorCount = 0;
                 // Allocate maximum storage to deal with invalid indices safely
                 const uint32_t maxColors = 256;
                 ColorMapObject* colorMap = fGif->Image.ColorMap;
                 // If there is no local color table, use the global color table
-                if (NULL == colorMap) {
+                if (nullptr == colorMap) {
                     colorMap = fGif->SColorMap;
                 }
-                if (NULL != colorMap) {
+                if (nullptr != colorMap) {
                     colorCount = colorMap->ColorCount;
                     SkASSERT(colorCount ==
                             (unsigned) (1 << (colorMap->BitsPerPixel)));
                     SkASSERT(colorCount <= 256);
                     for (uint32_t i = 0; i < colorCount; i++) {
                         colorTable[i] = SkPackARGB32(0xFF,
                                                      colorMap->Colors[i].Red,
                                                      colorMap->Colors[i].Green,
                                                      colorMap->Colors[i].Blue);
                     }
@@ skipping 34 matching lines @@
                         kYes_ZeroInitialized == zeroInit;
 
 
                 // Fill in the color table for indices greater than color count.
                 // This allows for predictable, safe behavior.
                 for (uint32_t i = colorCount; i < maxColors; i++) {
                     colorTable[i] = colorTable[fillIndex];
                 } 
 
                 // Check if image is only a subset of the image frame
-                SkAutoTDelete<SkSwizzler> swizzler(NULL);
+                SkAutoTDelete<SkSwizzler> swizzler(nullptr);
                 if (innerWidth < width || innerHeight < height) {
 
                     // Modify the destination info
                     const SkImageInfo subsetDstInfo =
                             dstInfo.makeWH(innerWidth, innerHeight);
 
                     // Fill the destination with the fill color
                     // FIXME: This may not be the behavior that we want for
                     //        animated gifs where we draw on top of the
                     //        previous frame.
@@ skipping 96 matching lines @@
             // such as transparency or animation.
             case EXTENSION_RECORD_TYPE:
                 // Read extension data
                 if (GIF_ERROR ==
                         DGifGetExtension(fGif, &extFunction, &extData)) {
                     return gif_error("Could not get extension.\n",
                             kIncompleteInput);
                 }
 
                 // Create an extension block with our data
-                while (NULL != extData) {
+                while (nullptr != extData) {
                     // Add a single block
                     if (GIF_ERROR ==
                             GifAddExtensionBlock(&saveExt.ExtensionBlockCount,
                             &saveExt.ExtensionBlocks, extFunction, extData[0],
                             &extData[1])) {
                         return gif_error("Could not add extension block.\n",
                                 kIncompleteInput);
                     }
                     // Move to the next block
                     if (GIF_ERROR == DGifGetExtensionNext(fGif, &extData)) {
@@ skipping 11 matching lines @@
                 // giflib returns an error code if the record type is not known.
                 // We should catch this error immediately.
                 SkASSERT(false);
                 break;
         }
     } while (TERMINATE_RECORD_TYPE != recordType);
 
     return gif_error("Could not find any images to decode in gif file.\n",
             kInvalidInput);
 }