Style Change: NULL->nullptr

src/core/SkBlitter_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 "SkCoreBlitters.h"
 #include "SkColorPriv.h"
 #include "SkShader.h"
@@ skipping 41 matching lines @@
     fSrcB = SkAlphaMul(SkColorGetB(color), scale);
 
     fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
 }
 
 const SkPixmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) {
     if (255 == fSrcA) {
         *value = fPMColor;
         return &fDevice;
     }
-    return NULL;
+    return nullptr;
 }
 
 #if defined _WIN32 && _MSC_VER >= 1300  // disable warning : local variable used without having been initialized
 #pragma warning ( push )
 #pragma warning ( disable : 4701 )
 #endif
 
 void SkARGB32_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
 
@@ skipping 258 matching lines @@
     int flags = 0;
     if (!(shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag)) {
         flags |= SkBlitRow::kSrcPixelAlpha_Flag32;
     }
     // we call this on the output from the shader
     fProc32 = SkBlitRow::Factory32(flags);
     // we call this on the output from the shader + alpha from the aa buffer
     fProc32Blend = SkBlitRow::Factory32(flags | SkBlitRow::kGlobalAlpha_Flag32);
 
     fShadeDirectlyIntoDevice = false;
-    if (fXfermode == NULL) {
+    if (fXfermode == nullptr) {
         if (shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) {
             fShadeDirectlyIntoDevice = true;
         }
     } else {
         SkXfermode::Mode mode;
         if (fXfermode->asMode(&mode)) {
             if (SkXfermode::kSrc_Mode == mode) {
                 fShadeDirectlyIntoDevice = true;
                 fProc32Blend = blend_srcmode;
             }
@@ skipping 12 matching lines @@
     SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
 
     uint32_t* device = fDevice.writable_addr32(x, y);
 
     if (fShadeDirectlyIntoDevice) {
         fShaderContext->shadeSpan(x, y, device, width);
     } else {
         SkPMColor*  span = fBuffer;
         fShaderContext->shadeSpan(x, y, span, width);
         if (fXfermode) {
-            fXfermode->xfer32(device, span, width, NULL);
+            fXfermode->xfer32(device, span, width, nullptr);
         } else {
             fProc32(device, span, width, 255);
         }
     }
 }
 
 void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) {
     SkASSERT(x >= 0 && y >= 0 &&
              x + width <= fDevice.width() && y + height <= fDevice.height());
 
     uint32_t*          device = fDevice.writable_addr32(x, y);
     size_t             deviceRB = fDevice.rowBytes();
     SkShader::Context* shaderContext = fShaderContext;
     SkPMColor*         span = fBuffer;
 
     if (fConstInY) {
         if (fShadeDirectlyIntoDevice) {
             // shade the first row directly into the device
             shaderContext->shadeSpan(x, y, device, width);
             span = device;
             while (--height > 0) {
                 device = (uint32_t*)((char*)device + deviceRB);
                 memcpy(device, span, width << 2);
             }
         } else {
             shaderContext->shadeSpan(x, y, span, width);
             SkXfermode* xfer = fXfermode;
             if (xfer) {
                 do {
-                    xfer->xfer32(device, span, width, NULL);
+                    xfer->xfer32(device, span, width, nullptr);
                     y += 1;
                     device = (uint32_t*)((char*)device + deviceRB);
                 } while (--height > 0);
             } else {
                 SkBlitRow::Proc32 proc = fProc32;
                 do {
                     proc(device, span, width, 255);
                     y += 1;
                     device = (uint32_t*)((char*)device + deviceRB);
                 } while (--height > 0);
@@ skipping 16 matching lines @@
                 shaderContext->shadeSpan(x, y, device, width);
                 y += 1;
                 device = (uint32_t*)((char*)device + deviceRB);
             } while (--height > 0);
         }
     } else {
         SkXfermode* xfer = fXfermode;
         if (xfer) {
             do {
                 shaderContext->shadeSpan(x, y, span, width);
-                xfer->xfer32(device, span, width, NULL);
+                xfer->xfer32(device, span, width, nullptr);
                 y += 1;
                 device = (uint32_t*)((char*)device + deviceRB);
             } while (--height > 0);
         } else {
             SkBlitRow::Proc32 proc = fProc32;
             do {
                 shaderContext->shadeSpan(x, y, span, width);
                 proc(device, span, width, 255);
                 y += 1;
                 device = (uint32_t*)((char*)device + deviceRB);
@@ skipping 12 matching lines @@
         for (;;) {
             SkXfermode* xfer = fXfermode;
 
             int count = *runs;
             if (count <= 0)
                 break;
             int aa = *antialias;
             if (aa) {
                 shaderContext->shadeSpan(x, y, span, count);
                 if (aa == 255) {
-                    xfer->xfer32(device, span, count, NULL);
+                    xfer->xfer32(device, span, count, nullptr);
                 } else {
                     // count is almost always 1
                     for (int i = count - 1; i >= 0; --i) {
                         xfer->xfer32(&device[i], &span[i], 1, antialias);
                     }
                 }
             }
             device += count;
             runs += count;
             antialias += count;
@@ skipping 47 matching lines @@
 void SkARGB32_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
     // we only handle kA8 with an xfermode
     if (fXfermode && (SkMask::kA8_Format != mask.fFormat)) {
         this->INHERITED::blitMask(mask, clip);
         return;
     }
 
     SkASSERT(mask.fBounds.contains(clip));
 
     SkShader::Context*  shaderContext = fShaderContext;
-    SkBlitMask::RowProc proc = NULL;
+    SkBlitMask::RowProc proc = nullptr;
     if (!fXfermode) {
         unsigned flags = 0;
         if (shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) {
             flags |= SkBlitMask::kSrcIsOpaque_RowFlag;
         }
         proc = SkBlitMask::RowFactory(kN32_SkColorType, mask.fFormat,
                                       (SkBlitMask::RowFlags)flags);
-        if (NULL == proc) {
+        if (nullptr == proc) {
             this->INHERITED::blitMask(mask, clip);
             return;
         }
     }
 
     const int x = clip.fLeft;
     const int width = clip.width();
     int y = clip.fTop;
     int height = clip.height();
 
@@ skipping 115 matching lines @@
             SkBlitRow::Proc32 proc = (255 == alpha) ? fProc32 : fProc32Blend;
             do {
                 shaderContext->shadeSpan(x, y, span, 1);
                 proc(device, span, 1, alpha);
                 y += 1;
                 device = (uint32_t*)((char*)device + deviceRB);
             } while (--height > 0);
         }
     }
 }