Style Change: NULL->nullptr

src/core/SkPixmap.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 "SkColorPriv.h"
 #include "SkConfig8888.h"
 #include "SkMask.h"
 #include "SkPixmap.h"
 #include "SkUtils.h"
 
 void SkAutoPixmapUnlock::reset(const SkPixmap& pm, void (*unlock)(void*), void* ctx) {
-    SkASSERT(pm.addr() != NULL);
+    SkASSERT(pm.addr() != nullptr);
 
     this->unlock();
     fPixmap = pm;
     fUnlockProc = unlock;
     fUnlockContext = ctx;
     fIsLocked = true;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 void SkPixmap::reset() {
-    fPixels = NULL;
-    fCTable = NULL;
+    fPixels = nullptr;
+    fCTable = nullptr;
     fRowBytes = 0;
     fInfo = SkImageInfo::MakeUnknown();
 }
 
 void SkPixmap::reset(const SkImageInfo& info, const void* addr, size_t rowBytes, SkColorTable* ct) {
     if (addr) {
         SkASSERT(info.validRowBytes(rowBytes));
     }
     fPixels = addr;
     fCTable = ct;
     fRowBytes = rowBytes;
     fInfo = info;
 }
 
 bool SkPixmap::reset(const SkMask& src) {
     if (SkMask::kA8_Format == src.fFormat) {
         this->reset(SkImageInfo::MakeA8(src.fBounds.width(), src.fBounds.height()),
-                    src.fImage, src.fRowBytes, NULL);
+                    src.fImage, src.fRowBytes, nullptr);
         return true;
     }
     this->reset();
     return false;
 }
 
 bool SkPixmap::extractSubset(SkPixmap* result, const SkIRect& subset) const {
     SkIRect srcRect, r;
     srcRect.set(0, 0, this->width(), this->height());
     if (!r.intersect(srcRect, subset)) {
         return false;   // r is empty (i.e. no intersection)
     }
     
     // If the upper left of the rectangle was outside the bounds of this SkBitmap, we should have
     // exited above.
     SkASSERT(static_cast<unsigned>(r.fLeft) < static_cast<unsigned>(this->width()));
     SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
 
-    const void* pixels = NULL;
+    const void* pixels = nullptr;
     if (fPixels) {
         const size_t bpp = fInfo.bytesPerPixel();
         pixels = (const uint8_t*)fPixels + r.fTop * fRowBytes + r.fLeft * bpp;
     }
     result->reset(fInfo.makeWH(r.width(), r.height()), pixels, fRowBytes, fCTable);
     return true;
 }
 
 bool SkPixmap::readPixels(const SkImageInfo& requestedDstInfo, void* dstPixels, size_t dstRB,
                           int x, int y) const {
     if (kUnknown_SkColorType == requestedDstInfo.colorType()) {
         return false;
     }
-    if (NULL == dstPixels || dstRB < requestedDstInfo.minRowBytes()) {
+    if (nullptr == dstPixels || dstRB < requestedDstInfo.minRowBytes()) {
         return false;
     }
     if (0 == requestedDstInfo.width() || 0 == requestedDstInfo.height()) {
         return false;
     }
     
     SkIRect srcR = SkIRect::MakeXYWH(x, y, requestedDstInfo.width(), requestedDstInfo.height());
     if (!srcR.intersect(0, 0, this->width(), this->height())) {
         return false;
     }
@@ skipping 19 matching lines @@
 
 static uint16_t pack_8888_to_4444(unsigned a, unsigned r, unsigned g, unsigned b) {
     unsigned pixel = (SkA32To4444(a) << SK_A4444_SHIFT) |
     (SkR32To4444(r) << SK_R4444_SHIFT) |
     (SkG32To4444(g) << SK_G4444_SHIFT) |
     (SkB32To4444(b) << SK_B4444_SHIFT);
     return SkToU16(pixel);
 }
 
 bool SkPixmap::erase(SkColor color, const SkIRect& inArea) const {
-    if (NULL == fPixels) {
+    if (nullptr == fPixels) {
         return false;
     }
     SkIRect area;
     if (!area.intersect(this->bounds(), inArea)) {
         return false;
     }
 
     U8CPU a = SkColorGetA(color);
     U8CPU r = SkColorGetR(color);
     U8CPU g = SkColorGetG(color);
@@ skipping 70 matching lines @@
             break;
         }
         default:
             return false; // no change, so don't call notifyPixelsChanged()
     }
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkAutoPixmapStorage::SkAutoPixmapStorage() : fStorage(NULL) {}
+SkAutoPixmapStorage::SkAutoPixmapStorage() : fStorage(nullptr) {}
 
 SkAutoPixmapStorage::~SkAutoPixmapStorage() {
     this->freeStorage();
 }
 
 bool SkAutoPixmapStorage::tryAlloc(const SkImageInfo& info) {
     this->freeStorage();
     
     size_t rb = info.minRowBytes();
     size_t size = info.getSafeSize(rb);
     if (0 == size) {
         return false;
     }
     void* pixels = sk_malloc_flags(size, 0);
-    if (NULL == pixels) {
+    if (nullptr == pixels) {
         return false;
     }
     this->reset(info, pixels, rb);
     fStorage = pixels;
     return true;
 }
 
 void SkAutoPixmapStorage::alloc(const SkImageInfo& info) {
     if (!this->tryAlloc(info)) {
         sk_throw();
     }
 }