Style Change: NULL->nullptr

src/core/SkSpriteBlitter_ARGB32.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkSpriteBlitter.h"
@@ skipping 51 matching lines @@
 class Sprite_D32_XferFilter : public SkSpriteBlitter {
 public:
     Sprite_D32_XferFilter(const SkPixmap& source, const SkPaint& paint) : SkSpriteBlitter(source) {
         fColorFilter = paint.getColorFilter();
         SkSafeRef(fColorFilter);
 
         fXfermode = paint.getXfermode();
         SkSafeRef(fXfermode);
 
         fBufferSize = 0;
-        fBuffer = NULL;
+        fBuffer = nullptr;
 
         unsigned flags32 = 0;
         if (255 != paint.getAlpha()) {
             flags32 |= SkBlitRow::kGlobalAlpha_Flag32;
         }
         if (!source.isOpaque()) {
             flags32 |= SkBlitRow::kSrcPixelAlpha_Flag32;
         }
 
         fProc32 = SkBlitRow::Factory32(flags32);
@@ skipping 47 matching lines @@
 
         do {
             const SkPMColor* tmp = src;
 
             if (colorFilter) {
                 colorFilter->filterSpan(src, width, fBuffer);
                 tmp = fBuffer;
             }
 
             if (xfermode) {
-                xfermode->xfer32(dst, tmp, width, NULL);
+                xfermode->xfer32(dst, tmp, width, nullptr);
             } else {
                 fProc32(dst, tmp, width, fAlpha);
             }
 
             dst = (uint32_t* SK_RESTRICT)((char*)dst + dstRB);
             src = (const uint32_t* SK_RESTRICT)((const char*)src + srcRB);
         } while (--height != 0);
     }
 
 private:
@@ skipping 24 matching lines @@
         SkColorFilter* colorFilter = fColorFilter;
         SkXfermode* xfermode = fXfermode;
 
         do {
             fillbuffer(buffer, src, width);
 
             if (colorFilter) {
                 colorFilter->filterSpan(buffer, width, buffer);
             }
             if (xfermode) {
-                xfermode->xfer32(dst, buffer, width, NULL);
+                xfermode->xfer32(dst, buffer, width, nullptr);
             } else {
                 fProc32(dst, buffer, width, fAlpha);
             }
 
             dst = (SkPMColor* SK_RESTRICT)((char*)dst + dstRB);
             src = (const SkPMColor16* SK_RESTRICT)((const char*)src + srcRB);
         } while (--height != 0);
     }
 
 private:
@@ skipping 55 matching lines @@
             dst = (SkPMColor* SK_RESTRICT)((char*)dst + dstRB);
             src = (const SkPMColor16* SK_RESTRICT)((const char*)src + srcRB);
         } while (--height != 0);
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkSpriteBlitter* SkSpriteBlitter::ChooseD32(const SkPixmap& source, const SkPaint& paint,
         SkTBlitterAllocator* allocator) {
-    SkASSERT(allocator != NULL);
+    SkASSERT(allocator != nullptr);
 
-    if (paint.getMaskFilter() != NULL) {
-        return NULL;
+    if (paint.getMaskFilter() != nullptr) {
+        return nullptr;
     }
 
     U8CPU       alpha = paint.getAlpha();
     SkXfermode* xfermode = paint.getXfermode();
     SkColorFilter* filter = paint.getColorFilter();
-    SkSpriteBlitter* blitter = NULL;
+    SkSpriteBlitter* blitter = nullptr;
 
     switch (source.colorType()) {
         case kARGB_4444_SkColorType:
             if (alpha != 0xFF) {
-                return NULL;    // we only have opaque sprites
+                return nullptr;    // we only have opaque sprites
             }
             if (xfermode || filter) {
                 blitter = allocator->createT<Sprite_D32_S4444_XferFilter>(source, paint);
             } else if (source.isOpaque()) {
                 blitter = allocator->createT<Sprite_D32_S4444_Opaque>(source);
             } else {
                 blitter = allocator->createT<Sprite_D32_S4444>(source);
             }
             break;
         case kN32_SkColorType:
             if (xfermode || filter) {
                 if (255 == alpha) {
                     // this can handle xfermode or filter, but not alpha
                     blitter = allocator->createT<Sprite_D32_S32A_XferFilter>(source, paint);
                 }
             } else {
                 // this can handle alpha, but not xfermode or filter
                 blitter = allocator->createT<Sprite_D32_S32>(source, alpha);
             }
             break;
         default:
             break;
     }
     return blitter;
 }