Style Change: NULL->nullptr

src/gpu/GrBlurUtils.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBlurUtils.h"
 #include "GrDrawContext.h"
 #include "GrCaps.h"
@@ skipping 48 matching lines @@
                                   GrPaint* grp,
                                   SkPaint::Style style) {
     SkMask  srcM, dstM;
 
     if (!SkDraw::DrawToMask(devPath, &clipBounds, filter, &viewMatrix, &srcM,
                             SkMask::kComputeBoundsAndRenderImage_CreateMode, style)) {
         return false;
     }
     SkAutoMaskFreeImage autoSrc(srcM.fImage);
 
-    if (!filter->filterMask(&dstM, srcM, viewMatrix, NULL)) {
+    if (!filter->filterMask(&dstM, srcM, viewMatrix, nullptr)) {
         return false;
     }
     // this will free-up dstM when we're done (allocated in filterMask())
     SkAutoMaskFreeImage autoDst(dstM.fImage);
 
     if (clip_bounds_quick_reject(clipBounds, dstM.fBounds)) {
         return false;
     }
 
     // we now have a device-aligned 8bit mask in dstM, ready to be drawn using
@@ skipping 29 matching lines @@
     desc.fSampleCnt = doAA ? sampleCnt : 0;
     // We actually only need A8, but it often isn't supported as a
     // render target so default to RGBA_8888
     desc.fConfig = kRGBA_8888_GrPixelConfig;
 
     if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, desc.fSampleCnt > 0)) {
         desc.fConfig = kAlpha_8_GrPixelConfig;
     }
 
     GrTexture* mask = context->textureProvider()->createApproxTexture(desc);
-    if (NULL == mask) {
-        return NULL;
+    if (nullptr == mask) {
+        return nullptr;
     }
 
     SkRect clipRect = SkRect::MakeWH(maskRect.width(), maskRect.height());
 
     GrDrawContext* drawContext = context->drawContext();
     if (!drawContext) {
-        return NULL;
+        return nullptr;
     }
 
-    drawContext->clear(mask->asRenderTarget(), NULL, 0x0, true);
+    drawContext->clear(mask->asRenderTarget(), nullptr, 0x0, true);
 
     GrPaint tempPaint;
     tempPaint.setAntiAlias(doAA);
     tempPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
 
     // setup new clip
     GrClip clip(clipRect);
 
     // Draw the mask into maskTexture with the path's top-left at the origin using tempPaint.
     SkMatrix translate;
@@ skipping 22 matching lines @@
     SkPath* pathPtr = const_cast<SkPath*>(&origSrcPath);
     SkTLazy<SkPath> tmpPath;
     SkTLazy<SkPath> effectPath;
     SkPathEffect* pathEffect = paint.getPathEffect();
 
     SkMatrix viewMatrix = origViewMatrix;
 
     if (prePathMatrix) {
         // stroking, path effects, and blurs are supposed to be applied *after* the prePathMatrix.
         // The pre-path-matrix also should not affect shading.
-        if (NULL == paint.getMaskFilter() && NULL == pathEffect && NULL == paint.getShader() &&
+        if (nullptr == paint.getMaskFilter() && nullptr == pathEffect && nullptr == paint.getShader() &&
             (strokeInfo.isFillStyle() || strokeInfo.isHairlineStyle())) {
             viewMatrix.preConcat(*prePathMatrix);
         } else {
             SkPath* result = pathPtr;
 
             if (!pathIsMutable) {
                 result = tmpPath.init();
                 result->setIsVolatile(true);
                 pathIsMutable = true;
             }
             // should I push prePathMatrix on our MV stack temporarily, instead
             // of applying it here? See SkDraw.cpp
             pathPtr->transform(*prePathMatrix, result);
             pathPtr = result;
         }
     }
     // at this point we're done with prePathMatrix
     SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
 
     GrPaint grPaint;
     if (!SkPaint2GrPaint(context, renderTarget, paint, viewMatrix, true, &grPaint)) {
         return;
     }
 
-    const SkRect* cullRect = NULL;  // TODO: what is our bounds?
+    const SkRect* cullRect = nullptr;  // TODO: what is our bounds?
     if (!strokeInfo.isDashed() && pathEffect && pathEffect->filterPath(effectPath.init(), *pathPtr,
                                                                        &strokeInfo, cullRect)) {
         pathPtr = effectPath.get();
         pathIsMutable = true;
     }
 
     if (paint.getMaskFilter()) {
         if (!strokeInfo.isHairlineStyle()) {
             SkPath* strokedPath = pathIsMutable ? pathPtr : tmpPath.init();
             if (strokeInfo.isDashed()) {
@@ skipping 77 matching lines @@
                                                               SkPaint::kFill_Style;
         draw_with_mask_filter(drawContext, context->textureProvider(), renderTarget,
                               clip, viewMatrix, *devPathPtr,
                               paint.getMaskFilter(), clipBounds, &grPaint, style);
         return;
     }
 
     drawContext->drawPath(renderTarget, clip, grPaint, viewMatrix, *pathPtr, strokeInfo);
 }