Style Change: NULL->nullptr

src/codec/SkBmpStandardCodec.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 "SkBmpStandardCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkScanlineDecoder.h"
 #include "SkStream.h"
 
 /*
  * Creates an instance of the decoder
  * Called only by NewFromStream
  */
 SkBmpStandardCodec::SkBmpStandardCodec(const SkImageInfo& info, SkStream* stream,
                                        uint16_t bitsPerPixel, uint32_t numColors,
                                        uint32_t bytesPerColor, uint32_t offset,
                                        SkBmpCodec::RowOrder rowOrder, bool inIco)
     : INHERITED(info, stream, bitsPerPixel, rowOrder)
-    , fColorTable(NULL)
+    , fColorTable(nullptr)
     , fNumColors(this->computeNumColors(numColors))
     , fBytesPerColor(bytesPerColor)
     , fOffset(offset)
-    , fSwizzler(NULL)
-    , fSrcBuffer(NULL)
+    , fSwizzler(nullptr)
+    , fSrcBuffer(nullptr)
     , fInIco(inIco)
 {}
 
 /*
  * Initiates the bitmap decode
  */
 SkCodec::Result SkBmpStandardCodec::onGetPixels(const SkImageInfo& dstInfo,
                                         void* dst, size_t dstRowBytes,
                                         const Options& opts,
                                         SkPMColor* inputColorPtr,
                                         int* inputColorCount) {
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
     if (opts.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         SkCodecPrintf("Error: scaling not supported.\n");
         return kInvalidScale;
     }
     if (!conversion_possible(dstInfo, this->getInfo())) {
         SkCodecPrintf("Error: cannot convert input type to output type.\n");
         return kInvalidConversion;
     }
 
     // Create the color table if necessary and prepare the stream for decode
-    // Note that if it is non-NULL, inputColorCount will be modified
+    // Note that if it is non-nullptr, inputColorCount will be modified
     if (!this->createColorTable(dstInfo.alphaType(), inputColorCount)) {
         SkCodecPrintf("Error: could not create color table.\n");
         return kInvalidInput;
     }
 
     // Copy the color table to the client if necessary
     copy_color_table(dstInfo, fColorTable, inputColorPtr, inputColorCount);
 
     // Initialize a swizzler if necessary
     if (!this->initializeSwizzler(dstInfo, opts)) {
         SkCodecPrintf("Error: cannot initialize swizzler.\n");
         return kInvalidConversion;
     }
 
     return this->decode(dstInfo, dst, dstRowBytes, opts);
 }
 
 /*
  * Process the color table for the bmp input
  */
  bool SkBmpStandardCodec::createColorTable(SkAlphaType alphaType, int* numColors) {
     // Allocate memory for color table
     uint32_t colorBytes = 0;
     SkPMColor colorTable[256];
     if (this->bitsPerPixel() <= 8) {
         // Inform the caller of the number of colors
         uint32_t maxColors = 1 << this->bitsPerPixel();
-        if (NULL != numColors) {
+        if (nullptr != numColors) {
             // We set the number of colors to maxColors in order to ensure
             // safe memory accesses.  Otherwise, an invalid pixel could
             // access memory outside of our color table array.
             *numColors = maxColors;
         }
 
         // Read the color table from the stream
         colorBytes = fNumColors * fBytesPerColor;
         SkAutoTDeleteArray<uint8_t> cBuffer(new uint8_t[colorBytes]);
         if (stream()->read(cBuffer.get(), colorBytes) != colorBytes) {
             SkCodecPrintf("Error: unable to read color table.\n");
             return false;
         }
 
         // Choose the proper packing function
         SkPMColor (*packARGB) (uint32_t, uint32_t, uint32_t, uint32_t);
         switch (alphaType) {
             case kOpaque_SkAlphaType:
             case kUnpremul_SkAlphaType:
                 packARGB = &SkPackARGB32NoCheck;
                 break;
             case kPremul_SkAlphaType:
                 packARGB = &SkPreMultiplyARGB;
                 break;
             default:
                 // This should not be reached because conversion possible
                 // should fail if the alpha type is not one of the above
                 // values.
                 SkASSERT(false);
-                packARGB = NULL;
+                packARGB = nullptr;
                 break;
         }
 
         // Fill in the color table
         uint32_t i = 0;
         for (; i < fNumColors; i++) {
             uint8_t blue = get_byte(cBuffer.get(), i*fBytesPerColor);
             uint8_t green = get_byte(cBuffer.get(), i*fBytesPerColor + 1);
             uint8_t red = get_byte(cBuffer.get(), i*fBytesPerColor + 2);
             uint8_t alpha;
@@ skipping 77 matching lines @@
             return false;
     }
 
     // Get a pointer to the color table if it exists
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
 
     // Create swizzler
     fSwizzler.reset(SkSwizzler::CreateSwizzler(config,
             colorPtr, dstInfo, opts.fZeroInitialized, this->getInfo()));
 
-    if (NULL == fSwizzler.get()) {
+    if (nullptr == fSwizzler.get()) {
         return false;
     }
     return true;
 }
 
 /*
  * Choose a fill for failures due to an incomplete image.  We will use zero as
  * the default palette index, black for opaque images, and transparent for
  * non-opaque images.
  */
@@ skipping 104 matching lines @@
                 uint32_t alphaBit =
                         (fSrcBuffer.get()[quotient] >> shift) & 0x1;
                 dstRow[x] &= alphaBit - 1;
             }
         }
     }
 
     // Finished decoding the entire image
     return kSuccess;
 }