Style Change: NULL->nullptr

src/core/SkBitmapController.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 "SkBitmap.h"
 #include "SkBitmapController.h"
 #include "SkMatrix.h"
 #include "SkTemplates.h"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static bool valid_for_drawing(const SkBitmap& bm) {
     if (0 == bm.width() || 0 == bm.height()) {
         return false;   // nothing to draw
     }
-    if (NULL == bm.pixelRef()) {
+    if (nullptr == bm.pixelRef()) {
         return false;   // no pixels to read
     }
     if (bm.getTexture()) {
         // we can handle texture (ugh) since lockPixels will perform a read-back
         return true;
     }
     if (kIndex_8_SkColorType == bm.colorType()) {
         SkAutoLockPixels alp(bm); // but we need to call it before getColorTable() is safe.
         if (!bm.getColorTable()) {
             return false;
         }
     }
     return true;
 }
 
 SkBitmapController::State* SkBitmapController::requestBitmap(const SkBitmap& bm,
                                                              const SkMatrix& inv,
                                                              SkFilterQuality quality,
                                                              void* storage, size_t storageSize) {
     
     if (!valid_for_drawing(bm)) {
-        return NULL;
+        return nullptr;
     }
 
     State* state = this->onRequestBitmap(bm, inv, quality, storage, storageSize);
     if (state) {
-        if (NULL == state->fPixmap.addr()) {
+        if (nullptr == state->fPixmap.addr()) {
             SkInPlaceDeleteCheck(state, storage);
-            state = NULL;
+            state = nullptr;
         }
     }
     return state;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkBitmapCache.h"
 #include "SkBitmapScaler.h"
 #include "SkMipMap.h"
@@ skipping 95 matching lines @@
     SkASSERT(fQuality <= kMedium_SkFilterQuality);
     if (fQuality != kMedium_SkFilterQuality) {
         return false;
     }
     
     // Our default return state is to downgrade the request to Low, w/ or w/o setting fBitmap
     // to a valid bitmap.
     fQuality = kLow_SkFilterQuality;
     
     SkSize invScaleSize;
-    if (!fInvMatrix.decomposeScale(&invScaleSize, NULL)) {
+    if (!fInvMatrix.decomposeScale(&invScaleSize, nullptr)) {
         return false;
     }
     SkScalar invScale = SkScalarSqrt(invScaleSize.width() * invScaleSize.height());
     
     if (invScale > SK_Scalar1) {
         fCurrMip.reset(SkMipMapCache::FindAndRef(origBitmap));
-        if (NULL == fCurrMip.get()) {
+        if (nullptr == fCurrMip.get()) {
             fCurrMip.reset(SkMipMapCache::AddAndRef(origBitmap));
-            if (NULL == fCurrMip.get()) {
+            if (nullptr == fCurrMip.get()) {
                 return false;
             }
         }
         // diagnostic for a crasher...
-        if (NULL == fCurrMip->data()) {
+        if (nullptr == fCurrMip->data()) {
             sk_throw();
         }
         
         SkScalar levelScale = SkScalarInvert(invScale);
         SkMipMap::Level level;
         if (fCurrMip->extractLevel(levelScale, &level)) {
             SkScalar invScaleFixup = level.fScale;
             fInvMatrix.postScale(invScaleFixup, invScaleFixup);
             
             const SkImageInfo info = origBitmap.info().makeWH(level.fWidth, level.fHeight);
             // todo: if we could wrap the fCurrMip in a pixelref, then we could just install
             //       that here, and not need to explicitly track it ourselves.
             return fResultBitmap.installPixels(info, level.fPixels, level.fRowBytes);
         } else {
             // failed to extract, so release the mipmap
-            fCurrMip.reset(NULL);
+            fCurrMip.reset(nullptr);
         }
     }
     return false;
 }
 
 SkDefaultBitmapControllerState::SkDefaultBitmapControllerState(const SkBitmap& src,
                                                                const SkMatrix& inv,
                                                                SkFilterQuality qual) {
     fInvMatrix = inv;
     fQuality = qual;
 
     if (this->processHQRequest(src) || this->processMediumRequest(src)) {
         SkASSERT(fResultBitmap.getPixels());
     } else {
         fResultBitmap = src;
         fResultBitmap.lockPixels();
         // lock may fail to give us pixels
     }
     SkASSERT(fQuality <= kLow_SkFilterQuality);
 
     // fResultBitmap.getPixels() may be null, but our caller knows to check fPixmap.addr()
-    // and will destroy us if it is NULL.
+    // and will destroy us if it is nullptr.
     fPixmap.reset(fResultBitmap.info(), fResultBitmap.getPixels(), fResultBitmap.rowBytes(),
                   fResultBitmap.getColorTable());
 }
 
 SkBitmapController::State* SkDefaultBitmapController::onRequestBitmap(const SkBitmap& bm,
                                                                       const SkMatrix& inverse,
                                                                       SkFilterQuality quality,
                                                                       void* storage, size_t size) {
     return SkInPlaceNewCheck<SkDefaultBitmapControllerState>(storage, size, bm, inverse, quality);
 }