Style Change: NULL->nullptr

src/codec/SkSwizzler.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 "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkScaledCodec.h"
@@ skipping 499 matching lines @@
     return alphaMask != 0xFF;
 }
 */
 
 SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
                                        const SkPMColor* ctable,
                                        const SkImageInfo& dstInfo, 
                                        SkCodec::ZeroInitialized zeroInit, 
                                        const SkImageInfo& srcInfo) {
     if (dstInfo.colorType() == kUnknown_SkColorType || kUnknown == sc) {
-        return NULL;
+        return nullptr;
     }
     if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
-            && NULL == ctable) {
-        return NULL;
+            && nullptr == ctable) {
+        return nullptr;
     }
-    RowProc proc = NULL;
+    RowProc proc = nullptr;
 
     switch (sc) {
         case kBit:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_bit_to_n32;
                     break;
                 case kIndex_8_SkColorType:
                     proc = &swizzle_bit_to_index;
                     break;
@@ skipping 135 matching lines @@
             switch (dstInfo.colorType()) {
                 case kRGB_565_SkColorType:
                     proc = &sample565;
                     break;
                 default:
                     break;
             }
         default:
             break;
     }
-    if (NULL == proc) {
-        return NULL;
+    if (nullptr == proc) {
+        return nullptr;
     }
 
     // Store deltaSrc in bytes if it is an even multiple, otherwise use bits
     int deltaSrc = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : BitsPerPixel(sc);
 
     // get sampleX based on srcInfo and dstInfo dimensions
     int sampleX;
-    SkScaledCodec::ComputeSampleSize(dstInfo, srcInfo, &sampleX, NULL);
+    SkScaledCodec::ComputeSampleSize(dstInfo, srcInfo, &sampleX, nullptr);
 
     return new SkSwizzler(proc, ctable, deltaSrc, dstInfo, sampleX);
 }
 
 SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
                        int deltaSrc, const SkImageInfo& info, int sampleX)
     : fRowProc(proc)
     , fColorTable(ctable)
     , fDeltaSrc(deltaSrc)
     , fDstInfo(info)
     , fSampleX(sampleX)
     , fX0(sampleX == 1 ? 0 : sampleX >> 1)
 {
     // check that fX0 is less than original width
     SkASSERT(fX0 >= 0 && fX0 < fDstInfo.width() * fSampleX);
 }
 
 SkSwizzler::ResultAlpha SkSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
-    SkASSERT(NULL != dst && NULL != src);
+    SkASSERT(nullptr != dst && nullptr != src);
     return fRowProc(dst, src, fDstInfo.width(), fSampleX * fDeltaSrc, fX0 * fDeltaSrc, fColorTable);
 }
 
 void SkSwizzler::Fill(void* dstStartRow, const SkImageInfo& dstInfo, size_t dstRowBytes,
         uint32_t numRows, uint32_t colorOrIndex, const SkPMColor* colorTable) {
-    SkASSERT(dstStartRow != NULL);
+    SkASSERT(dstStartRow != nullptr);
     SkASSERT(numRows <= (uint32_t) dstInfo.height());
 
     // Calculate bytes to fill.  We use getSafeSize since the last row may not be padded.
     const size_t bytesToFill = dstInfo.makeWH(dstInfo.width(), numRows).getSafeSize(dstRowBytes);
 
     // Use the proper memset routine to fill the remaining bytes
     switch(dstInfo.colorType()) {
         case kN32_SkColorType:
             // Assume input is an index if we have a color table
             uint32_t color;
-            if (NULL != colorTable) {
+            if (nullptr != colorTable) {
                 SkASSERT(colorOrIndex == (uint8_t) colorOrIndex);
                 color = colorTable[colorOrIndex];
             // Otherwise, assume the input is a color
             } else {
                 color = colorOrIndex;
             }
 
             // We must fill row by row in the case of unaligned row bytes
             if (SkIsAlign4((size_t) dstStartRow) && SkIsAlign4(dstRowBytes)) {
                 sk_memset32((uint32_t*) dstStartRow, color,
@@ skipping 32 matching lines @@
             // bits of SK_ColorBLACK are identical to the 565 representation
             // for black.
             memset(dstStartRow, (uint16_t) colorOrIndex, bytesToFill);
             break;
         default:
             SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
             SkASSERT(false);
             break;
     }
 }