Style Change: NULL->nullptr

src/images/SkImageDecoder_libico.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 "SkColorPriv.h"
 #include "SkImageDecoder.h"
 #include "SkStream.h"
@@ skipping 109 matching lines @@
     // promote the sum to 64-bits to avoid overflow
     // Check that buffer is large enough to read image data
     if (offset > length || size > length || ((uint64_t)offset + size) > length) {
         return kFailure;
     }
 
     // Check to see if this is a PNG image inside the ICO
     {
         SkMemoryStream subStream(buf + offset, size, false);
         SkAutoTDelete<SkImageDecoder> otherDecoder(SkImageDecoder::Factory(&subStream));
-        if (otherDecoder.get() != NULL) {
+        if (otherDecoder.get() != nullptr) {
             // Disallow nesting ICO files within one another
             // FIXME: Can ICO files contain other formats besides PNG?
             if (otherDecoder->getFormat() == SkImageDecoder::kICO_Format) {
                 return kFailure;
             }
             // Set fields on the other decoder to be the same as this one.
             this->copyFieldsToOther(otherDecoder.get());
             const Result result = otherDecoder->decode(&subStream, bm, this->getDefaultPref(),
                                                        mode);
             // FIXME: Should we just return result here? Is it possible that data that looked like
@@ skipping 19 matching lines @@
     }
 
     // Check that buffer is large enough to read the bit depth
     if (length < offset + 16) {
         return kFailure;
     }
     int bitCount = read2Bytes(buf, offset+14);
 
     void (*placePixel)(const int pixelNo, const unsigned char* buf,
         const int xorOffset, int& x, int y, const int w,
-        SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) = NULL;
+        SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors) = nullptr;
     switch (bitCount)
     {
         case 1:
             placePixel = &editPixelBit1;
             colorCount = 2;
             break;
         case 4:
             placePixel = &editPixelBit4;
             colorCount = 16;
             break;
@@ skipping 24 matching lines @@
 
     int begin = SkToInt(offset + 40);
     // Check that the buffer is large enough to read the color table
     // For bmp-in-icos, there should be 4 bytes per color
     if (length < (size_t) (begin + 4*colorCount)) {
         return kFailure;
     }
 
     //this array represents the colortable
     //if i allow other types of bitmaps, it may actually be used as a part of the bitmap
-    SkPMColor* colors = NULL;
+    SkPMColor* colors = nullptr;
     int blue, green, red;
     if (colorCount)
     {
         colors = new SkPMColor[colorCount];
         for (int j = 0; j < colorCount; j++)
         {
             //should this be a function - maybe a #define?
             blue = readByte(buf, begin + 4*j);
             green = readByte(buf, begin + 4*j + 1);
             red = readByte(buf, begin + 4*j + 2);
@@ skipping 19 matching lines @@
     //if the andbitmap (mask) is all zeroes, then we can easily do an index bitmap
     //however, with small images with large colortables, maybe it's better to still do argb_8888
 
     bm->setInfo(SkImageInfo::MakeN32Premul(w, h), calculateRowBytesFor8888(w, bitCount));
 
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         delete[] colors;
         return kSuccess;
     }
 
-    if (!this->allocPixelRef(bm, NULL))
+    if (!this->allocPixelRef(bm, nullptr))
     {
         delete[] colors;
         return kFailure;
     }
 
     // The AND mask is a 1-bit alpha mask for each pixel that comes after the
     // XOR mask in the bmp.  If we check that the largest AND offset is safe,
     // it should mean all other buffer accesses will be at smaller indices and
     // will therefore be safe.
     size_t maxAndOffset = andOffset + ((andLineWidth*(h-1)+(w-1)) >> 3);
@@ skipping 164 matching lines @@
     }
     int reserved = read2Bytes(buf, 0);
     int type = read2Bytes(buf, 2);
     return 0 == reserved && 1 == type;
 }
 
 static SkImageDecoder* sk_libico_dfactory(SkStreamRewindable* stream) {
     if (is_ico(stream)) {
         return new SkICOImageDecoder;
     }
-    return NULL;
+    return nullptr;
 }
 
 static SkImageDecoder_DecodeReg gReg(sk_libico_dfactory);
 
 static SkImageDecoder::Format get_format_ico(SkStreamRewindable* stream) {
     if (is_ico(stream)) {
         return SkImageDecoder::kICO_Format;
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageDecoder_FormatReg gFormatReg(get_format_ico);