Style Change: NULL->nullptr

src/codec/SkCodec_wbmp.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.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 50 matching lines @@
     if (!read_mbf(stream, &height) || height > 0xFFFF || !height) {
         return false;
     }
     if (size) {
         *size = SkISize::Make(SkToS32(width), SkToS32(height));
     }
     return true;
 }
 
 bool SkWbmpCodec::onRewind() {
-    return read_header(this->stream(), NULL);
+    return read_header(this->stream(), nullptr);
 }
 
 SkSwizzler* SkWbmpCodec::initializeSwizzler(const SkImageInfo& info,
         const SkPMColor* ctable, const Options& opts) {
     // Create the swizzler based on the desired color type
     switch (info.colorType()) {
         case kIndex_8_SkColorType:
         case kN32_SkColorType:
         case kRGB_565_SkColorType:
         case kGray_8_SkColorType:
             return SkSwizzler::CreateSwizzler(SkSwizzler::kBit, ctable, info, opts.fZeroInitialized, 
                                               this->getInfo());
         default:
-            return NULL;
+            return nullptr;
     }
 }
 
 SkCodec::Result SkWbmpCodec::readRow(uint8_t* row) {
     if (this->stream()->read(row, fSrcRowBytes) != fSrcRowBytes) {
         return kIncompleteInput;
     }
     return kSuccess;
 }
 
@@ skipping 26 matching lines @@
     if (!valid_alpha(info.alphaType(), this->getInfo().alphaType())) {
         return SkCodec::kInvalidConversion;
     }
 
     // Prepare a color table if necessary
     setup_color_table(info.colorType(), ctable, ctableCount);
 
 
     // Initialize the swizzler
     SkAutoTDelete<SkSwizzler> swizzler(this->initializeSwizzler(info, ctable, options));
-    if (NULL == swizzler.get()) {
+    if (nullptr == swizzler.get()) {
         return kInvalidConversion;
     }
 
     // Perform the decode
     SkISize size = info.dimensions();
     SkAutoTMalloc<uint8_t> src(fSrcRowBytes);
     void* dstRow = dst;
     for (int y = 0; y < size.height(); ++y) {
         Result rowResult = this->readRow(src.get());
         if (kSuccess != rowResult) {
             return rowResult;
         }
         swizzler->swizzle(dstRow, src.get());
         dstRow = SkTAddOffset<void>(dstRow, rowBytes);
     }
     return kSuccess;
 }
 
 bool SkWbmpCodec::IsWbmp(SkStream* stream) {
-    return read_header(stream, NULL);
+    return read_header(stream, nullptr);
 }
 
 SkCodec* SkWbmpCodec::NewFromStream(SkStream* stream) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
     SkISize size;
     if (!read_header(stream, &size)) {
-        return NULL;
+        return nullptr;
     }
     SkImageInfo info = SkImageInfo::Make(size.width(), size.height(),
             kGray_8_SkColorType, kOpaque_SkAlphaType);
     return new SkWbmpCodec(info, streamDeleter.detach());
 }
 
 class SkWbmpScanlineDecoder : public SkScanlineDecoder {
 public:
     /*
      * Takes ownership of all pointer paramters.
      */
     SkWbmpScanlineDecoder(SkWbmpCodec* codec)
         : INHERITED(codec->getInfo())
         , fCodec(codec)
-        , fColorTable(NULL)
-        , fSwizzler(NULL)
+        , fColorTable(nullptr)
+        , fSwizzler(nullptr)
         , fSrcBuffer(codec->fSrcRowBytes)
     {}
 
     SkCodec::Result onGetScanlines(void* dst, int count, size_t dstRowBytes) override {
         void* dstRow = dst;
         for (int y = 0; y < count; ++y) {
             SkCodec::Result rowResult = fCodec->readRow(fSrcBuffer.get());
             if (SkCodec::kSuccess != rowResult) {
                 return rowResult;
             }
@@ skipping 27 matching lines @@
         setup_color_table(dstInfo.colorType(), inputColorTable, inputColorCount);
 
         // Copy the color table to a pointer that can be owned by the scanline decoder
         if (kIndex_8_SkColorType == dstInfo.colorType()) {
             fColorTable.reset(new SkColorTable(inputColorTable, 2));
         }
 
         // Initialize the swizzler
         fSwizzler.reset(fCodec->initializeSwizzler(dstInfo,
                 get_color_ptr(fColorTable.get()), options));
-        if (NULL == fSwizzler.get()) {
+        if (nullptr == fSwizzler.get()) {
             return SkCodec::kInvalidConversion;
         }
 
         return SkCodec::kSuccess;
     }
 
     SkEncodedFormat onGetEncodedFormat() const {
         return kWBMP_SkEncodedFormat;
     }
 
 private:
     SkAutoTDelete<SkWbmpCodec>   fCodec;
     SkAutoTUnref<SkColorTable>   fColorTable;
     SkAutoTDelete<SkSwizzler>    fSwizzler;
     SkAutoTMalloc<uint8_t>       fSrcBuffer;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkWbmpCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkWbmpCodec> codec(static_cast<SkWbmpCodec*>(
             SkWbmpCodec::NewFromStream(stream)));
     if (!codec) {
-        return NULL;
+        return nullptr;
     }
 
     // Return the new scanline decoder
     return new SkWbmpScanlineDecoder(codec.detach());
 }