Style Change: NULL->nullptr

src/core/SkBlitter_RGB16.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 "SkBlitRow.h"
 #include "SkCoreBlitters.h"
 #include "SkColorPriv.h"
@@ skipping 154 matching lines @@
     // illegal
     SkRGB16_Shader_Xfermode_Blitter& operator=(const SkRGB16_Shader_Xfermode_Blitter&);
 
     typedef SkShaderBlitter INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 #ifdef USE_BLACK_BLITTER
 SkRGB16_Black_Blitter::SkRGB16_Black_Blitter(const SkPixmap& device, const SkPaint& paint)
     : INHERITED(device, paint) {
-    SkASSERT(paint.getShader() == NULL);
-    SkASSERT(paint.getColorFilter() == NULL);
-    SkASSERT(paint.getXfermode() == NULL);
+    SkASSERT(paint.getShader() == nullptr);
+    SkASSERT(paint.getColorFilter() == nullptr);
+    SkASSERT(paint.getXfermode() == nullptr);
     SkASSERT(paint.getColor() == SK_ColorBLACK);
 }
 
 #if 1
 #define black_8_pixels(mask, dst)       \
     do {                                \
         if (mask & 0x80) dst[0] = 0;    \
         if (mask & 0x40) dst[1] = 0;    \
         if (mask & 0x20) dst[2] = 0;    \
         if (mask & 0x10) dst[3] = 0;    \
@@ skipping 373 matching lines @@
     }
 
     fColorProc16 = SkBlitRow::ColorFactory16(flags);
 }
 
 const SkPixmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) {
     if (!fDoDither && 256 == fScale) {
         *value = fRawColor16;
         return &fDevice;
     }
-    return NULL;
+    return nullptr;
 }
 
 void SkRGB16_Blitter::blitH(int x, int y, int width) {
     SkASSERT(width > 0);
     SkASSERT(x + width <= fDevice.width());
     uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
 
     fColorProc16(device, fSrcColor32, width, x, y);
 }
 
@@ skipping 233 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkPixmap& device,
                                                const SkPaint& paint,
                                                SkShader::Context* shaderContext)
     : INHERITED(device, paint, shaderContext)
 {
-    SkASSERT(paint.getXfermode() == NULL);
+    SkASSERT(paint.getXfermode() == nullptr);
 
     fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * sizeof(SkPMColor));
 
     // compute SkBlitRow::Procs
     unsigned flags = 0;
 
     uint32_t shaderFlags = fShaderFlags;
     // shaders take care of global alpha, so we never set it in SkBlitRow
     if (!(shaderFlags & SkShader::kOpaqueAlpha_Flag)) {
         flags |= SkBlitRow::kSrcPixelAlpha_Flag;
@@ skipping 127 matching lines @@
     sk_free(fBuffer);
 }
 
 void SkRGB16_Shader_Xfermode_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x + width <= fDevice.width());
 
     uint16_t*   device = fDevice.writable_addr16(x, y);
     SkPMColor*  span = fBuffer;
 
     fShaderContext->shadeSpan(x, y, span, width);
-    fXfermode->xfer16(device, span, width, NULL);
+    fXfermode->xfer16(device, span, width, nullptr);
 }
 
 void SkRGB16_Shader_Xfermode_Blitter::blitAntiH(int x, int y,
                                 const SkAlpha* SK_RESTRICT antialias,
                                 const int16_t* SK_RESTRICT runs) {
     SkShader::Context*     shaderContext = fShaderContext;
     SkXfermode*            mode = fXfermode;
     SkPMColor* SK_RESTRICT span = fBuffer;
     uint8_t* SK_RESTRICT   aaExpand = fAAExpand;
     uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
@@ skipping 15 matching lines @@
         int nonZeroCount = count + count_nonzero_span(runs + count,
                                                       antialias + count);
 
         SkASSERT(nonZeroCount <= fDevice.width()); // don't overrun fBuffer
         shaderContext->shadeSpan(x, y, span, nonZeroCount);
 
         x += nonZeroCount;
         SkPMColor* localSpan = span;
         for (;;) {
             if (aa == 0xFF) {
-                mode->xfer16(device, localSpan, count, NULL);
+                mode->xfer16(device, localSpan, count, nullptr);
             } else {
                 SkASSERT(aa);
                 memset(aaExpand, aa, count);
                 mode->xfer16(device, localSpan, count, aaExpand);
             }
             device += count;
             runs += count;
             antialias += count;
             nonZeroCount -= count;
             if (nonZeroCount == 0) {
                 break;
             }
             localSpan += count;
             SkASSERT(nonZeroCount > 0);
             count = *runs;
             SkASSERT(count > 0);
             aa = *antialias;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
         SkShader::Context* shaderContext,
         SkTBlitterAllocator* allocator) {
-    SkASSERT(allocator != NULL);
+    SkASSERT(allocator != nullptr);
 
     SkBlitter* blitter;
     SkShader* shader = paint.getShader();
     SkXfermode* mode = paint.getXfermode();
 
     // we require a shader if there is an xfermode, handled by our caller
-    SkASSERT(NULL == mode || shader);
+    SkASSERT(nullptr == mode || shader);
 
     if (shader) {
-        SkASSERT(shaderContext != NULL);
+        SkASSERT(shaderContext != nullptr);
         if (mode) {
             blitter = allocator->createT<SkRGB16_Shader_Xfermode_Blitter>(device, paint,
                                                                           shaderContext);
         } else if (shaderContext->canCallShadeSpan16()) {
             blitter = allocator->createT<SkRGB16_Shader16_Blitter>(device, paint, shaderContext);
         } else {
             blitter = allocator->createT<SkRGB16_Shader_Blitter>(device, paint, shaderContext);
         }
     } else {
         // no shader, no xfermode, (and we always ignore colorfilter)
         SkColor color = paint.getColor();
         if (0 == SkColorGetA(color)) {
             blitter = allocator->createT<SkNullBlitter>();
 #ifdef USE_BLACK_BLITTER
         } else if (SK_ColorBLACK == color) {
             blitter = allocator->createT<SkRGB16_Black_Blitter>(device, paint);
 #endif
         } else if (0xFF == SkColorGetA(color)) {
             blitter = allocator->createT<SkRGB16_Opaque_Blitter>(device, paint);
         } else {
             blitter = allocator->createT<SkRGB16_Blitter>(device, paint);
         }
     }
 
     return blitter;
 }