Style Change: NULL->nullptr

src/core/SkBlitter.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 "SkBlitter.h"
 #include "SkAntiRun.h"
 #include "SkColor.h"
@@ skipping 11 matching lines @@
 
 SkBlitter::~SkBlitter() {}
 
 bool SkBlitter::isNullBlitter() const { return false; }
 
 bool SkBlitter::resetShaderContext(const SkShader::ContextRec&) {
     return true;
 }
 
 SkShader::Context* SkBlitter::getShaderContext() const {
-    return NULL;
+    return nullptr;
 }
 
 const SkPixmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
-    return NULL;
+    return nullptr;
 }
 
 void SkBlitter::blitH(int x, int y, int width) {
     SkDEBUGFAIL("unimplemented");
 }
 
 void SkBlitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                           const int16_t runs[]) {
     SkDEBUGFAIL("unimplemented");
 }
@@ skipping 189 matching lines @@
 void SkNullBlitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                               const int16_t runs[]) {}
 
 void SkNullBlitter::blitV(int x, int y, int height, SkAlpha alpha) {}
 
 void SkNullBlitter::blitRect(int x, int y, int width, int height) {}
 
 void SkNullBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {}
 
 const SkPixmap* SkNullBlitter::justAnOpaqueColor(uint32_t* value) {
-    return NULL;
+    return nullptr;
 }
 
 bool SkNullBlitter::isNullBlitter() const { return true; }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int compute_anti_width(const int16_t runs[]) {
     int width = 0;
 
     for (;;) {
@@ skipping 289 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBlitter* SkBlitterClipper::apply(SkBlitter* blitter, const SkRegion* clip,
                                    const SkIRect* ir) {
     if (clip) {
         const SkIRect& clipR = clip->getBounds();
 
         if (clip->isEmpty() || (ir && !SkIRect::Intersects(clipR, *ir))) {
             blitter = &fNullBlitter;
         } else if (clip->isRect()) {
-            if (ir == NULL || !clipR.contains(*ir)) {
+            if (ir == nullptr || !clipR.contains(*ir)) {
                 fRectBlitter.init(blitter, clipR);
                 blitter = &fRectBlitter;
             }
         } else {
             fRgnBlitter.init(blitter, clip);
             blitter = &fRgnBlitter;
         }
     }
     return blitter;
 }
@@ skipping 15 matching lines @@
 
     size_t contextSize() const override {
         size_t size = sizeof(Sk3DShaderContext);
         if (fProxy) {
             size += fProxy->contextSize();
         }
         return size;
     }
 
     Context* onCreateContext(const ContextRec& rec, void* storage) const override {
-        SkShader::Context* proxyContext = NULL;
+        SkShader::Context* proxyContext = nullptr;
         if (fProxy) {
             char* proxyContextStorage = (char*) storage + sizeof(Sk3DShaderContext);
             proxyContext = fProxy->createContext(rec, proxyContextStorage);
             if (!proxyContext) {
-                return NULL;
+                return nullptr;
             }
         }
         return new (storage) Sk3DShaderContext(*this, rec, proxyContext);
     }
 
     class Sk3DShaderContext : public SkShader::Context {
     public:
         // Calls proxyContext's destructor but will NOT free its memory.
         Sk3DShaderContext(const Sk3DShader& shader, const ContextRec& rec,
                           SkShader::Context* proxyContext)
             : INHERITED(shader, rec)
-            , fMask(NULL)
+            , fMask(nullptr)
             , fProxyContext(proxyContext)
         {
             if (!fProxyContext) {
                 fPMColor = SkPreMultiplyColor(rec.fPaint->getColor());
             }
         }
 
         virtual ~Sk3DShaderContext() {
             if (fProxyContext) {
                 fProxyContext->~Context();
             }
         }
 
         void set3DMask(const SkMask* mask) override { fMask = mask; }
 
         void shadeSpan(int x, int y, SkPMColor span[], int count) override {
             if (fProxyContext) {
                 fProxyContext->shadeSpan(x, y, span, count);
             }
 
-            if (fMask == NULL) {
-                if (fProxyContext == NULL) {
+            if (fMask == nullptr) {
+                if (fProxyContext == nullptr) {
                     sk_memset32(span, fPMColor, count);
                 }
                 return;
             }
 
             SkASSERT(fMask->fBounds.contains(x, y));
             SkASSERT(fMask->fBounds.contains(x + count - 1, y));
 
             size_t          size = fMask->computeImageSize();
             const uint8_t*  alpha = fMask->getAddr8(x, y);
@@ skipping 112 matching lines @@
     }
 
     void blitMask(const SkMask& mask, const SkIRect& clip) override {
         if (mask.fFormat == SkMask::k3D_Format) {
             fShaderContext->set3DMask(&mask);
 
             ((SkMask*)&mask)->fFormat = SkMask::kA8_Format;
             fProxy->blitMask(mask, clip);
             ((SkMask*)&mask)->fFormat = SkMask::k3D_Format;
 
-            fShaderContext->set3DMask(NULL);
+            fShaderContext->set3DMask(nullptr);
         } else {
             fProxy->blitMask(mask, clip);
         }
     }
 
 private:
     // Both pointers are unowned. They will be deleted by SkSmallAllocator.
     SkBlitter*          fProxy;
     SkShader::Context*  fShaderContext;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkCoreBlitters.h"
 
 SkBlitter* SkBlitter::Choose(const SkPixmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& origPaint,
                              SkTBlitterAllocator* allocator,
                              bool drawCoverage) {
-    SkASSERT(allocator != NULL);
+    SkASSERT(allocator != nullptr);
 
     // which check, in case we're being called by a client with a dummy device
     // (e.g. they have a bounder that always aborts the draw)
     if (kUnknown_SkColorType == device.colorType() ||
             (drawCoverage && (kAlpha_8_SkColorType != device.colorType()))) {
         return allocator->createT<SkNullBlitter>();
     }
 
     SkShader* shader = origPaint.getShader();
     SkColorFilter* cf = origPaint.getColorFilter();
     SkXfermode* mode = origPaint.getXfermode();
-    Sk3DShader* shader3D = NULL;
+    Sk3DShader* shader3D = nullptr;
 
     SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
 
-    if (origPaint.getMaskFilter() != NULL &&
+    if (origPaint.getMaskFilter() != nullptr &&
             origPaint.getMaskFilter()->getFormat() == SkMask::k3D_Format) {
         shader3D = new Sk3DShader(shader);
         // we know we haven't initialized lazyPaint yet, so just do it
         paint.writable()->setShader(shader3D)->unref();
         shader = shader3D;
     }
 
     if (mode) {
         bool deviceIsOpaque = kRGB_565_SkColorType == device.colorType();
         switch (SkInterpretXfermode(*paint, deviceIsOpaque)) {
             case kSrcOver_SkXfermodeInterpretation:
-                mode = NULL;
-                paint.writable()->setXfermode(NULL);
+                mode = nullptr;
+                paint.writable()->setXfermode(nullptr);
                 break;
             case kSkipDrawing_SkXfermodeInterpretation:{
                 return allocator->createT<SkNullBlitter>();
             }
             default:
                 break;
         }
     }
 
     /*
      *  If the xfermode is CLEAR, then we can completely ignore the installed
      *  color/shader/colorfilter, and just pretend we're SRC + color==0. This
      *  will fall into our optimizations for SRC mode.
      */
     if (SkXfermode::IsMode(mode, SkXfermode::kClear_Mode)) {
         SkPaint* p = paint.writable();
-        shader = p->setShader(NULL);
-        cf = p->setColorFilter(NULL);
+        shader = p->setShader(nullptr);
+        cf = p->setColorFilter(nullptr);
         mode = p->setXfermodeMode(SkXfermode::kSrc_Mode);
         p->setColor(0);
     }
 
-    if (NULL == shader) {
+    if (nullptr == shader) {
         if (mode) {
             // xfermodes (and filters) require shaders for our current blitters
             shader = new SkColorShader(paint->getColor());
             paint.writable()->setShader(shader)->unref();
             paint.writable()->setAlpha(0xFF);
         } else if (cf) {
             // if no shader && no xfermode, we just apply the colorfilter to
             // our color and move on.
             SkPaint* writablePaint = paint.writable();
             writablePaint->setColor(cf->filterColor(paint->getColor()));
-            writablePaint->setColorFilter(NULL);
-            cf = NULL;
+            writablePaint->setColorFilter(nullptr);
+            cf = nullptr;
         }
     }
 
     if (cf) {
         SkASSERT(shader);
         shader = new SkFilterShader(shader, cf);
         paint.writable()->setShader(shader)->unref();
         // blitters should ignore the presence/absence of a filter, since
         // if there is one, the shader will take care of it.
     }
 
     /*
      *  We create a SkShader::Context object, and store it on the blitter.
      */
-    SkShader::Context* shaderContext = NULL;
+    SkShader::Context* shaderContext = nullptr;
     if (shader) {
-        SkShader::ContextRec rec(*paint, matrix, NULL);
+        SkShader::ContextRec rec(*paint, matrix, nullptr);
         size_t contextSize = shader->contextSize();
         if (contextSize) {
             // Try to create the ShaderContext
             void* storage = allocator->reserveT<SkShader::Context>(contextSize);
             shaderContext = shader->createContext(rec, storage);
             if (!shaderContext) {
                 allocator->freeLast();
                 return allocator->createT<SkNullBlitter>();
             }
             SkASSERT(shaderContext);
             SkASSERT((void*) shaderContext == storage);
         } else {
             return allocator->createT<SkNullBlitter>();
         }
     }
 
-    SkBlitter*  blitter = NULL;
+    SkBlitter*  blitter = nullptr;
     switch (device.colorType()) {
         case kAlpha_8_SkColorType:
             if (drawCoverage) {
-                SkASSERT(NULL == shader);
-                SkASSERT(NULL == paint->getXfermode());
+                SkASSERT(nullptr == shader);
+                SkASSERT(nullptr == paint->getXfermode());
                 blitter = allocator->createT<SkA8_Coverage_Blitter>(device, *paint);
             } else if (shader) {
                 blitter = allocator->createT<SkA8_Shader_Blitter>(device, *paint, shaderContext);
             } else {
                 blitter = allocator->createT<SkA8_Blitter>(device, *paint);
             }
             break;
 
         case kRGB_565_SkColorType:
             blitter = SkBlitter_ChooseD565(device, *paint, shaderContext, allocator);
@@ skipping 27 matching lines @@
     }
     return blitter;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkZeroShaderContext : public SkShader::Context {
 public:
     SkZeroShaderContext(const SkShader& shader, const SkShader::ContextRec& rec)
         // Override rec with the identity matrix, so it is guaranteed to be invertible.
-        : INHERITED(shader, SkShader::ContextRec(*rec.fPaint, SkMatrix::I(), NULL)) {}
+        : INHERITED(shader, SkShader::ContextRec(*rec.fPaint, SkMatrix::I(), nullptr)) {}
 
     void shadeSpan(int x, int y, SkPMColor colors[], int count) override {
         sk_bzero(colors, count * sizeof(SkPMColor));
     }
 
 private:
     typedef SkShader::Context INHERITED;
 };
 
 SkShaderBlitter::SkShaderBlitter(const SkPixmap& device, const SkPaint& paint,
@@ skipping 13 matching lines @@
 }
 
 bool SkShaderBlitter::resetShaderContext(const SkShader::ContextRec& rec) {
     // Only destroy the old context if we have a new one. We need to ensure to have a
     // live context in fShaderContext because the storage is owned by an SkSmallAllocator
     // outside of this class.
     // The new context will be of the same size as the old one because we use the same
     // shader to create it. It is therefore safe to re-use the storage.
     fShaderContext->~Context();
     SkShader::Context* ctx = fShader->createContext(rec, (void*)fShaderContext);
-    if (NULL == ctx) {
+    if (nullptr == ctx) {
         // Need a valid context in fShaderContext's storage, so we can later (or our caller) call
         // the in-place destructor.
         new (fShaderContext) SkZeroShaderContext(*fShader, rec);
         return false;
     }
     return true;
 }