Style Change: NULL->nullptr

src/core/SkDraw.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.
  */
 #define __STDC_LIMIT_MACROS
 
 #include "SkDraw.h"
 #include "SkBlitter.h"
@@ skipping 24 matching lines @@
 #include "SkMatrixUtils.h"
 
 //#define TRACE_BITMAP_DRAWS
 
 
 /** Helper for allocating small blitters on the stack.
  */
 class SkAutoBlitterChoose : SkNoncopyable {
 public:
     SkAutoBlitterChoose() {
-        fBlitter = NULL;
+        fBlitter = nullptr;
     }
     SkAutoBlitterChoose(const SkPixmap& dst, const SkMatrix& matrix,
                         const SkPaint& paint, bool drawCoverage = false) {
         fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage);
     }
     
     SkBlitter*  operator->() { return fBlitter; }
     SkBlitter*  get() const { return fBlitter; }
 
     void choose(const SkPixmap& dst, const SkMatrix& matrix,
@@ skipping 10 matching lines @@
 #define SkAutoBlitterChoose(...) SK_REQUIRE_LOCAL_VAR(SkAutoBlitterChoose)
 
 /**
  *  Since we are providing the storage for the shader (to avoid the perf cost
  *  of calling new) we insist that in our destructor we can account for all
  *  owners of the shader.
  */
 class SkAutoBitmapShaderInstall : SkNoncopyable {
 public:
     SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint& paint,
-                              const SkMatrix* localMatrix = NULL)
+                              const SkMatrix* localMatrix = nullptr)
             : fPaint(paint) /* makes a copy of the paint */ {
         fPaint.setShader(SkCreateBitmapShader(src, SkShader::kClamp_TileMode,
                                               SkShader::kClamp_TileMode,
                                               localMatrix, &fAllocator));
         // we deliberately left the shader with an owner-count of 2
         SkASSERT(2 == fPaint.getShader()->getRefCnt());
     }
 
     ~SkAutoBitmapShaderInstall() {
         // since fAllocator will destroy shader, we insist that owners == 2
         SkASSERT(2 == fPaint.getShader()->getRefCnt());
 
-        fPaint.setShader(NULL); // unref the shader by 1
+        fPaint.setShader(nullptr); // unref the shader by 1
 
     }
 
     // return the new paint that has the shader applied
     const SkPaint& paintWithShader() const { return fPaint; }
 
 private:
     // copy of caller's paint (which we then modify)
     SkPaint             fPaint;
     // Stores the shader.
@@ skipping 48 matching lines @@
 
 static void DA8_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
     memset(pixels, data, bytes);
 }
 
 static BitmapXferProc ChooseBitmapXferProc(const SkPixmap& dst, const SkPaint& paint,
                                            uint32_t* data) {
     // todo: we can apply colorfilter up front if no shader, so we wouldn't
     // need to abort this fastpath
     if (paint.getShader() || paint.getColorFilter()) {
-        return NULL;
+        return nullptr;
     }
 
     SkXfermode::Mode mode;
     if (!SkXfermode::AsMode(paint.getXfermode(), &mode)) {
-        return NULL;
+        return nullptr;
     }
 
     SkColor color = paint.getColor();
 
     // collaps modes based on color...
     if (SkXfermode::kSrcOver_Mode == mode) {
         unsigned alpha = SkColorGetA(color);
         if (0 == alpha) {
             mode = SkXfermode::kDst_Mode;
         } else if (0xFF == alpha) {
@@ skipping 33 matching lines @@
 //                    SkDebugf("--- DA8_Src_BitmapXferProc\n");
                     return DA8_Src_BitmapXferProc;
                 default:
                     break;
             }
             break;
         }
         default:
             break;
     }
-    return NULL;
+    return nullptr;
 }
 
 static void CallBitmapXferProc(const SkPixmap& dst, const SkIRect& rect, BitmapXferProc proc,
                                uint32_t procData) {
     int shiftPerPixel;
     switch (dst.colorType()) {
         case kN32_SkColorType:
             shiftPerPixel = 2;
             break;
         case kRGB_565_SkColorType:
@@ skipping 216 matching lines @@
         return false;
     }
 
     if (paint.getPathEffect()) {
         return false;
     }
     SkScalar width = paint.getStrokeWidth();
     if (0 == width) {
         fMode = mode;
         fPaint = &paint;
-        fClip = NULL;
+        fClip = nullptr;
         fRC = rc;
         fRadius = SK_FixedHalf;
         return true;
     }
     if (paint.getStrokeCap() != SkPaint::kRound_Cap &&
         matrix->isScaleTranslate() && SkCanvas::kPoints_PointMode == mode) {
         SkScalar sx = matrix->get(SkMatrix::kMScaleX);
         SkScalar sy = matrix->get(SkMatrix::kMScaleY);
         if (SkScalarNearlyZero(sx - sy)) {
             if (sx < 0) {
                 sx = -sx;
             }
 
             fMode = mode;
             fPaint = &paint;
-            fClip = NULL;
+            fClip = nullptr;
             fRC = rc;
             fRadius = SkScalarToFixed(SkScalarMul(width, sx)) >> 1;
             return true;
         }
     }
     return false;
 }
 
 PtProcRec::Proc PtProcRec::chooseProc(SkBlitter** blitterPtr) {
-    Proc proc = NULL;
+    Proc proc = nullptr;
 
     SkBlitter* blitter = *blitterPtr;
     if (fRC->isBW()) {
         fClip = &fRC->bwRgn();
     } else {
         fWrapper.init(*fRC, blitter);
         fClip = &fWrapper.getRgn();
         blitter = fWrapper.getBlitter();
         *blitterPtr = blitter;
     }
@@ skipping 48 matching lines @@
                         bool forceUseDevice) const {
     // if we're in lines mode, force count to be even
     if (SkCanvas::kLines_PointMode == mode) {
         count &= ~(size_t)1;
     }
 
     if ((long)count <= 0) {
         return;
     }
 
-    SkASSERT(pts != NULL);
+    SkASSERT(pts != nullptr);
     SkDEBUGCODE(this->validate();)
 
      // nothing to draw
     if (fRC->isEmpty()) {
         return;
     }
 
     PtProcRec rec;
     if (!forceUseDevice && rec.init(mode, paint, fMatrix, fRC)) {
         SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
@@ skipping 75 matching lines @@
                     path.moveTo(pts[0]);
                     path.lineTo(pts[1]);
 
                     SkRect cullRect = SkRect::Make(fRC->getBounds());
 
                     if (paint.getPathEffect()->asPoints(&pointData, path, rec,
                                                         *fMatrix, &cullRect)) {
                         // 'asPoints' managed to find some fast path
 
                         SkPaint newP(paint);
-                        newP.setPathEffect(NULL);
+                        newP.setPathEffect(nullptr);
                         newP.setStyle(SkPaint::kFill_Style);
 
                         if (!pointData.fFirst.isEmpty()) {
                             if (fDevice) {
                                 fDevice->drawPath(*this, pointData.fFirst, newP);
                             } else {
                                 this->drawPath(pointData.fFirst, newP);
                             }
                         }
 
@@ skipping 57 matching lines @@
                 count -= 1;
                 SkPath path;
                 SkPaint p(paint);
                 p.setStyle(SkPaint::kStroke_Style);
                 size_t inc = (SkCanvas::kLines_PointMode == mode) ? 2 : 1;
                 path.setIsVolatile(true);
                 for (size_t i = 0; i < count; i += inc) {
                     path.moveTo(pts[i]);
                     path.lineTo(pts[i+1]);
                     if (fDevice) {
-                        fDevice->drawPath(*this, path, p, NULL, true);
+                        fDevice->drawPath(*this, path, p, nullptr, true);
                     } else {
-                        this->drawPath(path, p, NULL, true);
+                        this->drawPath(path, p, nullptr, true);
                     }
                     path.rewind();
                 }
                 break;
             }
         }
     }
 }
 
 static inline SkPoint compute_stroke_size(const SkPaint& paint, const SkMatrix& matrix) {
@@ skipping 77 matching lines @@
     RectType rtype = ComputeRectType(paint, *fMatrix, &strokeSize);
 
     if (kPath_RectType == rtype) {
         SkDraw draw(*this);
         if (paintMatrix) {
             draw.fMatrix = matrix;
         }
         SkPath  tmp;
         tmp.addRect(prePaintRect);
         tmp.setFillType(SkPath::kWinding_FillType);
-        draw.drawPath(tmp, paint, NULL, true);
+        draw.drawPath(tmp, paint, nullptr, true);
         return;
     }
 
     SkRect devRect;
     const SkRect& paintRect = paintMatrix ? *postPaintRect : prePaintRect;
     // skip the paintMatrix when transforming the rect by the CTM
     fMatrix->mapPoints(rect_points(devRect), rect_points(paintRect), 2);
     devRect.sort();
 
     // look for the quick exit, before we build a blitter
@@ skipping 60 matching lines @@
 
 void SkDraw::drawDevMask(const SkMask& srcM, const SkPaint& paint) const {
     if (srcM.fBounds.isEmpty()) {
         return;
     }
 
     const SkMask* mask = &srcM;
 
     SkMask dstM;
     if (paint.getMaskFilter() &&
-            paint.getMaskFilter()->filterMask(&dstM, srcM, *fMatrix, NULL)) {
+            paint.getMaskFilter()->filterMask(&dstM, srcM, *fMatrix, nullptr)) {
         mask = &dstM;
     } else {
-        dstM.fImage = NULL;
+        dstM.fImage = nullptr;
     }
     SkAutoMaskFreeImage ami(dstM.fImage);
 
     SkAutoBlitterChoose blitterChooser(fDst, *fMatrix, paint);
     SkBlitter* blitter = blitterChooser.get();
 
     SkAAClipBlitterWrapper wrapper;
     const SkRegion* clipRgn;
 
     if (fRC->isBW()) {
@@ skipping 73 matching lines @@
                                                    SkPaint::kFill_Style)) {
                 return; // filterRRect() called the blitter, so we're done
             }
         }
     }
 
 DRAW_PATH:
     // Now fall back to the default case of using a path.
     SkPath path;
     path.addRRect(rrect);
-    this->drawPath(path, paint, NULL, true);
+    this->drawPath(path, paint, nullptr, true);
 }
 
 static SkScalar compute_res_scale_for_stroking(const SkMatrix& matrix) {
     if (!matrix.hasPerspective()) {
         SkScalar sx = SkPoint::Length(matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewY]);
         SkScalar sy = SkPoint::Length(matrix[SkMatrix::kMSkewX],  matrix[SkMatrix::kMScaleY]);
         if (SkScalarsAreFinite(sx, sy)) {
             return SkTMax(sx, sy);
         }
     }
@@ skipping 57 matching lines @@
 #endif
                 SkPaint* writablePaint = paint.writable();
                 writablePaint->setStrokeWidth(0);
                 writablePaint->setAlpha(newAlpha);
             }
         }
     }
 
     if (paint->getPathEffect() || paint->getStyle() != SkPaint::kFill_Style) {
         SkRect cullRect;
-        const SkRect* cullRectPtr = NULL;
+        const SkRect* cullRectPtr = nullptr;
         if (this->computeConservativeLocalClipBounds(&cullRect)) {
             cullRectPtr = &cullRect;
         }
         doFill = paint->getFillPath(*pathPtr, &tmpPath, cullRectPtr,
                                     compute_res_scale_for_stroking(*fMatrix));
         pathPtr = &tmpPath;
     }
 
     if (paint->getRasterizer()) {
         SkMask  mask;
         if (paint->getRasterizer()->rasterize(*pathPtr, *matrix,
                             &fRC->getBounds(), paint->getMaskFilter(), &mask,
                             SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
             this->drawDevMask(mask, *paint);
             SkMask::FreeImage(mask.fImage);
         }
         return;
     }
 
     // avoid possibly allocating a new path in transform if we can
     SkPath* devPathPtr = pathIsMutable ? pathPtr : &tmpPath;
 
     // transform the path into device space
     pathPtr->transform(*matrix, devPathPtr);
 
-    SkBlitter* blitter = NULL;
+    SkBlitter* blitter = nullptr;
     SkAutoBlitterChoose blitterStorage;
-    if (NULL == customBlitter) {
+    if (nullptr == customBlitter) {
         blitterStorage.choose(fDst, *fMatrix, *paint, drawCoverage);
         blitter = blitterStorage.get();
     } else {
         blitter = customBlitter;
     }
 
     if (paint->getMaskFilter()) {
         SkPaint::Style style = doFill ? SkPaint::kFill_Style :
             SkPaint::kStroke_Style;
         if (paint->getMaskFilter()->filterPath(*devPathPtr, *fMatrix, *fRC, blitter, style)) {
@@ skipping 208 matching lines @@
 
     SkPaint paint(origPaint);
     paint.setStyle(SkPaint::kFill_Style);
 
     SkAutoPixmapUnlock unlocker;
     if (!bitmap.requestLock(&unlocker)) {
         return;
     }
     const SkPixmap& pmap = unlocker.pixmap();
 
-    if (NULL == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
+    if (nullptr == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
         SkTBlitterAllocator allocator;
         // blitter will be owned by the allocator.
         SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator);
         if (blitter) {
             SkScan::FillIRect(bounds, *fRC, blitter);
             return;
         }
     }
 
     SkMatrix        matrix;
@@ skipping 99 matching lines @@
         (fx >> 16) < INT_MIN - (INT16_MIN + 0 /*UINT16_MIN*/) ||
         (fy >> 16) > INT_MAX - (INT16_MAX + UINT16_MAX) ||
         (fy >> 16) < INT_MIN - (INT16_MIN + 0 /*UINT16_MIN*/))
     {
         return;
     }
 
     int left = Sk48Dot16FloorToInt(fx);
     int top = Sk48Dot16FloorToInt(fy);
     SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
-    SkASSERT((NULL == state.fClip && state.fAAClip) ||
-             (state.fClip && NULL == state.fAAClip && state.fClip->isRect()));
+    SkASSERT((nullptr == state.fClip && state.fAAClip) ||
+             (state.fClip && nullptr == state.fAAClip && state.fClip->isRect()));
 
     left += glyph.fLeft;
     top  += glyph.fTop;
 
     int right   = left + glyph.fWidth;
     int bottom  = top + glyph.fHeight;
 
     SkMask        mask;
     SkIRect        storage;
     SkIRect*    bounds = &mask.fBounds;
 
     mask.fBounds.set(left, top, right, bottom);
 
     // this extra test is worth it, assuming that most of the time it succeeds
     // since we can avoid writing to storage
     if (!state.fClipBounds.containsNoEmptyCheck(left, top, right, bottom)) {
         if (!storage.intersectNoEmptyCheck(mask.fBounds, state.fClipBounds))
             return;
         bounds = &storage;
     }
 
     uint8_t* aa = (uint8_t*)glyph.fImage;
-    if (NULL == aa) {
+    if (nullptr == aa) {
         aa = (uint8_t*)state.fCache->findImage(glyph);
-        if (NULL == aa) {
+        if (nullptr == aa) {
             return; // can't rasterize glyph
         }
     }
 
     mask.fRowBytes = glyph.rowBytes();
     mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
     mask.fImage = aa;
     state.blitMask(mask, *bounds);
 }
 
 static void D1G_RgnClip(const SkDraw1Glyph& state, Sk48Dot16 fx, Sk48Dot16 fy, const SkGlyph& glyph) {
     int left = Sk48Dot16FloorToInt(fx);
     int top = Sk48Dot16FloorToInt(fy);
     SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
     SkASSERT(!state.fClip->isRect());
 
     SkMask  mask;
 
     left += glyph.fLeft;
     top  += glyph.fTop;
 
     mask.fBounds.set(left, top, left + glyph.fWidth, top + glyph.fHeight);
     SkRegion::Cliperator clipper(*state.fClip, mask.fBounds);
 
     if (!clipper.done()) {
         const SkIRect&  cr = clipper.rect();
         const uint8_t*  aa = (const uint8_t*)glyph.fImage;
-        if (NULL == aa) {
+        if (nullptr == aa) {
             aa = (uint8_t*)state.fCache->findImage(glyph);
-            if (NULL == aa) {
+            if (nullptr == aa) {
                 return;
             }
         }
 
         mask.fRowBytes = glyph.rowBytes();
         mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
         mask.fImage = (uint8_t*)aa;
         do {
             state.blitMask(mask, cr);
             clipper.next();
@@ skipping 23 matching lines @@
     }
 
     if (hasCustomD1GProc(*draw)) {
         // todo: fix this assumption about clips w/ custom
         fClip = draw->fClip;
         fClipBounds = fClip->getBounds();
         return draw->fProcs->fD1GProc;
     }
 
     if (draw->fRC->isBW()) {
-        fAAClip = NULL;
+        fAAClip = nullptr;
         fClip = &draw->fRC->bwRgn();
         fClipBounds = fClip->getBounds();
         if (fClip->isRect()) {
             return D1G_RectClip;
         } else {
             return D1G_RgnClip;
         }
     } else {    // aaclip
         fAAClip = &draw->fRC->aaRgn();
-        fClip = NULL;
+        fClip = nullptr;
         fClipBounds = fAAClip->getBounds();
         return D1G_RectClip;
     }
 }
 
 void SkDraw1Glyph::blitMaskAsSprite(const SkMask& mask) const {
     SkASSERT(SkMask::kARGB32_Format == mask.fFormat);
 
     SkBitmap bm;
     bm.installPixels(SkImageInfo::MakeN32Premul(mask.fBounds.width(), mask.fBounds.height()),
                      (SkPMColor*)mask.fImage, mask.fRowBytes);
 
     fDraw->drawSprite(bm, mask.fBounds.x(), mask.fBounds.y(), *fPaint);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkDraw::drawText(const char text[], size_t byteLength,
                       SkScalar x, SkScalar y, const SkPaint& paint) const {
-    SkASSERT(byteLength == 0 || text != NULL);
+    SkASSERT(byteLength == 0 || text != nullptr);
 
     SkDEBUGCODE(this->validate();)
 
     // nothing to draw
-    if (text == NULL || byteLength == 0 || fRC->isEmpty()) {
+    if (text == nullptr || byteLength == 0 || fRC->isEmpty()) {
         return;
     }
 
     // SkScalarRec doesn't currently have a way of representing hairline stroke and
     // will fill if its frame-width is 0.
     if (ShouldDrawTextAsPaths(paint, *fMatrix)) {
         this->drawText_asPaths(text, byteLength, x, y, paint);
         return;
     }
 
@@ skipping 24 matching lines @@
             stopY = SkScalarHalf(stopY);
         }
         x -= stopX;
         y -= stopY;
     }
 
     const char* stop = text + byteLength;
 
     SkAAClipBlitter     aaBlitter;
     SkAutoBlitterChoose blitterChooser;
-    SkBlitter*          blitter = NULL;
+    SkBlitter*          blitter = nullptr;
     if (needsRasterTextBlit(*this)) {
         blitterChooser.choose(fDst, *fMatrix, paint);
         blitter = blitterChooser.get();
         if (fRC->isAA()) {
             aaBlitter.init(blitter, &fRC->aaRgn());
             blitter = &aaBlitter;
         }
     }
 
     SkAutoKern          autokern;
@@ skipping 37 matching lines @@
                                  const SkPoint& offset, const SkPaint& origPaint) const {
     // setup our std paint, in hopes of getting hits in the cache
     SkPaint paint(origPaint);
     SkScalar matrixScale = paint.setupForAsPaths();
 
     SkMatrix matrix;
     matrix.setScale(matrixScale, matrixScale);
 
     // Temporarily jam in kFill, so we only ever ask for the raw outline from the cache.
     paint.setStyle(SkPaint::kFill_Style);
-    paint.setPathEffect(NULL);
+    paint.setPathEffect(nullptr);
 
     SkDrawCacheProc     glyphCacheProc = paint.getDrawCacheProc();
-    SkAutoGlyphCache    autoCache(paint, &fDevice->surfaceProps(), NULL);
+    SkAutoGlyphCache    autoCache(paint, &fDevice->surfaceProps(), nullptr);
     SkGlyphCache*       cache = autoCache.getCache();
 
     const char*        stop = text + byteLength;
     SkTextAlignProc    alignProc(paint.getTextAlign());
     SkTextMapStateProc tmsProc(SkMatrix::I(), offset, scalarsPerPosition);
 
     // Now restore the original settings, so we "draw" with whatever style/stroking.
     paint.setStyle(origPaint.getStyle());
     paint.setPathEffect(origPaint.getPathEffect());
 
@@ skipping 16 matching lines @@
                 }
             }
         }
         pos += scalarsPerPosition;
     }
 }
 
 void SkDraw::drawPosText(const char text[], size_t byteLength,
                          const SkScalar pos[], int scalarsPerPosition,
                          const SkPoint& offset, const SkPaint& paint) const {
-    SkASSERT(byteLength == 0 || text != NULL);
+    SkASSERT(byteLength == 0 || text != nullptr);
     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 
     SkDEBUGCODE(this->validate();)
 
     // nothing to draw
-    if (text == NULL || byteLength == 0 || fRC->isEmpty()) {
+    if (text == nullptr || byteLength == 0 || fRC->isEmpty()) {
         return;
     }
 
     if (ShouldDrawTextAsPaths(paint, *fMatrix)) {
         this->drawPosText_asPaths(text, byteLength, pos, scalarsPerPosition, offset, paint);
         return;
     }
 
     SkDrawCacheProc     glyphCacheProc = paint.getDrawCacheProc();
     SkAutoGlyphCache    autoCache(paint, &fDevice->surfaceProps(), fMatrix);
     SkGlyphCache*       cache = autoCache.getCache();
 
     SkAAClipBlitterWrapper wrapper;
     SkAutoBlitterChoose blitterChooser;
-    SkBlitter* blitter = NULL;
+    SkBlitter* blitter = nullptr;
     if (needsRasterTextBlit(*this)) {
         blitterChooser.choose(fDst, *fMatrix, paint);
         blitter = blitterChooser.get();
         if (fRC->isAA()) {
             wrapper.init(*fRC, blitter);
             blitter = wrapper.getBlitter();
         }
     }
 
     const char*        stop = text + byteLength;
@@ skipping 142 matching lines @@
     private:
         SkMatrix    fDstToUnit;
         SkPMColor   fColors[3];
 
         typedef SkShader::Context INHERITED;
     };
 
     SK_TO_STRING_OVERRIDE()
 
     // For serialization.  This will never be called.
-    Factory getFactory() const override { sk_throw(); return NULL; }
+    Factory getFactory() const override { sk_throw(); return nullptr; }
 
 protected:
     Context* onCreateContext(const ContextRec& rec, void* storage) const override {
         return new (storage) TriColorShaderContext(*this, rec);
     }
 
 private:
     typedef SkShader INHERITED;
 };
 
@@ skipping 117 matching lines @@
         - just texture (has shader/texture[], no colors[])
         - colors * texture (has shader/texture[], has colors[])
 
         Thus for texture drawing, we need both texture[] and a shader.
     */
 
     SkTriColorShader triShader; // must be above declaration of p
     SkPaint p(paint);
 
     SkShader* shader = p.getShader();
-    if (NULL == shader) {
+    if (nullptr == shader) {
         // if we have no shader, we ignore the texture coordinates
-        textures = NULL;
-    } else if (NULL == textures) {
+        textures = nullptr;
+    } else if (nullptr == textures) {
         // if we don't have texture coordinates, ignore the shader
-        p.setShader(NULL);
-        shader = NULL;
+        p.setShader(nullptr);
+        shader = nullptr;
     }
 
     // setup the custom shader (if needed)
     SkAutoTUnref<SkComposeShader> composeShader;
     if (colors) {
-        if (NULL == textures) {
+        if (nullptr == textures) {
             // just colors (no texture)
             shader = p.setShader(&triShader);
         } else {
             // colors * texture
             SkASSERT(shader);
             bool releaseMode = false;
-            if (NULL == xmode) {
+            if (nullptr == xmode) {
                 xmode = SkXfermode::Create(SkXfermode::kModulate_Mode);
                 releaseMode = true;
             }
             composeShader.reset(new SkComposeShader(&triShader, shader, xmode));
             p.setShader(composeShader);
             if (releaseMode) {
                 xmode->unref();
             }
         }
     }
@@ skipping 62 matching lines @@
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 
 void SkDraw::validate() const {
-    SkASSERT(fMatrix != NULL);
-    SkASSERT(fClip != NULL);
-    SkASSERT(fRC != NULL);
+    SkASSERT(fMatrix != nullptr);
+    SkASSERT(fClip != nullptr);
+    SkASSERT(fRC != nullptr);
 
     const SkIRect&  cr = fRC->getBounds();
     SkIRect         br;
 
     br.set(0, 0, fDst.width(), fDst.height());
     SkASSERT(cr.isEmpty() || br.contains(cr));
 }
 
 #endif
 
@@ skipping 15 matching lines @@
     *bounds = devPath.getBounds().makeOutset(SK_ScalarHalf, SK_ScalarHalf).roundOut();
 
     SkIPoint margin = SkIPoint::Make(0, 0);
     if (filter) {
         SkASSERT(filterMatrix);
 
         SkMask srcM, dstM;
 
         srcM.fBounds = *bounds;
         srcM.fFormat = SkMask::kA8_Format;
-        srcM.fImage = NULL;
+        srcM.fImage = nullptr;
         if (!filter->filterMask(&dstM, srcM, *filterMatrix, &margin)) {
             return false;
         }
     }
 
     // (possibly) trim the bounds to reflect the clip
     // (plus whatever slop the filter needs)
     if (clipBounds) {
         // Ugh. Guard against gigantic margins from wacky filters. Without this
         // check we can request arbitrary amounts of slop beyond our visible
@@ skipping 53 matching lines @@
         mask->fImage = SkMask::AllocImage(size);
         memset(mask->fImage, 0, mask->computeImageSize());
     }
 
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
         draw_into_mask(*mask, devPath, style);
     }
 
     return true;
 }