Style Change: NULL->nullptr

src/images/SkImageDecoder_libgif.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
@@ skipping 59 matching lines @@
         SkASSERT(fDeltaYPtr);
 
         int y = fCurrY + fDeltaY;
         // We went from an if statement to a while loop so that we iterate
         // through fStartYPtr until a valid row is found. This is so that images
         // that are smaller than 5x5 will not trash memory.
         while (y >= fHeight) {
             if (gStartingIterlaceYValue +
                     SK_ARRAY_COUNT(gStartingIterlaceYValue) == fStartYPtr) {
                 // we done
-                SkDEBUGCODE(fStartYPtr = NULL;)
-                SkDEBUGCODE(fDeltaYPtr = NULL;)
+                SkDEBUGCODE(fStartYPtr = nullptr;)
+                SkDEBUGCODE(fDeltaYPtr = nullptr;)
                 y = 0;
             } else {
                 y = *fStartYPtr++;
                 fDeltaY = *fDeltaYPtr++;
             }
         }
         fCurrY = y;
     }
 
 private:
@@ skipping 15 matching lines @@
 void CheckFreeExtension(SavedImage* Image) {
     if (Image->ExtensionBlocks) {
 #if GIFLIB_MAJOR < 5
         FreeExtension(Image);
 #else
         GifFreeExtensions(&Image->ExtensionBlockCount, &Image->ExtensionBlocks);
 #endif
     }
 }
 
-// return NULL on failure
+// return nullptr on failure
 static const ColorMapObject* find_colormap(const GifFileType* gif) {
     const ColorMapObject* cmap = gif->Image.ColorMap;
-    if (NULL == cmap) {
+    if (nullptr == cmap) {
         cmap = gif->SColorMap;
     }
 
-    if (NULL == cmap) {
+    if (nullptr == cmap) {
         // no colormap found
-        return NULL;
+        return nullptr;
     }
     // some sanity checks
     if (cmap && ((unsigned)cmap->ColorCount > 256 ||
                  cmap->ColorCount != (1 << cmap->BitsPerPixel))) {
-        cmap = NULL;
+        cmap = nullptr;
     }
     return cmap;
 }
 
 // return -1 if not found (i.e. we're completely opaque)
 static int find_transpIndex(const SavedImage& image, int colorCount) {
     int transpIndex = -1;
     for (int i = 0; i < image.ExtensionBlockCount; ++i) {
         const ExtensionBlock* eb = image.ExtensionBlocks + i;
         if (eb->Function == 0xF9 && eb->ByteCount == 4) {
@@ skipping 48 matching lines @@
  *  GIFs with fewer then 256 color entries will sometimes index out of
  *  bounds of the color table (this is malformed, but libgif does not
  *  check sicne it is rare).  This function checks for this error and
  *  fixes it.  This makes the output image consistantly deterministic.
  */
 static void sanitize_indexed_bitmap(SkBitmap* bm) {
     if ((kIndex_8_SkColorType == bm->colorType()) && !(bm->empty())) {
         SkAutoLockPixels alp(*bm);
         if (bm->getPixels()) {
             SkColorTable* ct = bm->getColorTable();  // Index8 must have it.
-            SkASSERT(ct != NULL);
+            SkASSERT(ct != nullptr);
             uint32_t count = ct->count();
             SkASSERT(count > 0);
             SkASSERT(count <= 0x100);
             if (count != 0x100) {  // Full colortables can't go wrong.
                 // Count is a power of 2; asserted elsewhere.
                 uint8_t byteMask = (~(count - 1));
                 bool warning = false;
                 uint8_t* addr = static_cast<uint8_t*>(bm->getPixels());
                 int height = bm->height();
                 int width = bm->width();
@@ skipping 17 matching lines @@
         }
     }
 }
 
 namespace {
 // This function is a template argument, so can't be static.
 int close_gif(GifFileType* gif) {
 #if GIFLIB_MAJOR < 5 || (GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 0)
     return DGifCloseFile(gif);
 #else
-    return DGifCloseFile(gif, NULL);
+    return DGifCloseFile(gif, nullptr);
 #endif
 }
 }//namespace
 
 SkImageDecoder::Result SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, Mode mode) {
 #if GIFLIB_MAJOR < 5
     GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc);
 #else
-    GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc, NULL);
+    GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc, nullptr);
 #endif
-    if (NULL == gif) {
+    if (nullptr == gif) {
         return error_return(*bm, "DGifOpen");
     }
 
     SkAutoTCallIProc<GifFileType, close_gif> acp(gif);
 
     SavedImage temp_save;
-    temp_save.ExtensionBlocks=NULL;
+    temp_save.ExtensionBlocks=nullptr;
     temp_save.ExtensionBlockCount=0;
     SkAutoTCallVProc<SavedImage, CheckFreeExtension> acp2(&temp_save);
 
     int width, height;
     GifRecordType recType;
     GifByteType *extData;
 #if GIFLIB_MAJOR >= 5
     int extFunction;
 #endif
     int transpIndex = -1;   // -1 means we don't have it (yet)
@@ skipping 63 matching lines @@
                 return kSuccess;
             }
 
 
             // now we decode the colortable
             int colorCount = 0;
             {
                 // Declare colorPtr here for scope.
                 SkPMColor colorPtr[256]; // storage for worst-case
                 const ColorMapObject* cmap = find_colormap(gif);
-                if (cmap != NULL) {
+                if (cmap != nullptr) {
                     SkASSERT(cmap->ColorCount == (1 << (cmap->BitsPerPixel)));
                     colorCount = cmap->ColorCount;
                     if (colorCount > 256) {
                         colorCount = 256;  // our kIndex8 can't support more
                     }
                     for (int index = 0; index < colorCount; index++) {
                         colorPtr[index] = SkPackARGB32(0xFF,
                                                        cmap->Colors[index].Red,
                                                        cmap->Colors[index].Green,
                                                        cmap->Colors[index].Blue);
                     }
                 } else {
-                    // find_colormap() returned NULL.  Some (rare, broken)
+                    // find_colormap() returned nullptr.  Some (rare, broken)
                     // GIFs don't have a color table, so we force one.
                     gif_warning(*bm, "missing colormap");
                     colorCount = 256;
                     sk_memset32(colorPtr, SK_ColorWHITE, colorCount);
                 }
                 transpIndex = find_transpIndex(temp_save, colorCount);
                 if (transpIndex >= 0) {
                     colorPtr[transpIndex] = SK_ColorTRANSPARENT; // ram in a transparent SkPMColor
                     fillIndex = transpIndex;
                 } else if (fillIndex >= colorCount) {
@@ skipping 100 matching lines @@
         case EXTENSION_RECORD_TYPE:
 #if GIFLIB_MAJOR < 5
             if (DGifGetExtension(gif, &temp_save.Function,
                                  &extData) == GIF_ERROR) {
 #else
             if (DGifGetExtension(gif, &extFunction, &extData) == GIF_ERROR) {
 #endif
                 return error_return(*bm, "DGifGetExtension");
             }
 
-            while (extData != NULL) {
+            while (extData != nullptr) {
                 /* Create an extension block with our data */
 #if GIFLIB_MAJOR < 5
                 if (AddExtensionBlock(&temp_save, extData[0],
                                       &extData[1]) == GIF_ERROR) {
 #else
                 if (GifAddExtensionBlock(&temp_save.ExtensionBlockCount,
                                          &temp_save.ExtensionBlocks,
                                          extFunction,
                                          extData[0],
                                          &extData[1]) == GIF_ERROR) {
@@ skipping 34 matching lines @@
             return true;
         }
     }
     return false;
 }
 
 static SkImageDecoder* sk_libgif_dfactory(SkStreamRewindable* stream) {
     if (is_gif(stream)) {
         return new SkGIFImageDecoder;
     }
-    return NULL;
+    return nullptr;
 }
 
 static SkImageDecoder_DecodeReg gReg(sk_libgif_dfactory);
 
 static SkImageDecoder::Format get_format_gif(SkStreamRewindable* stream) {
     if (is_gif(stream)) {
         return SkImageDecoder::kGIF_Format;
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageDecoder_FormatReg gFormatReg(get_format_gif);