Style Change: NULL->nullptr

tests/BlurTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
 #include "SkBlurDrawLooper.h"
@@ skipping 153 matching lines @@
                             int* result, int resultCount) {
     SkMask src, dst;
 
     src.fBounds.set(0, 0, width, height);
     src.fFormat = SkMask::kA8_Format;
     src.fRowBytes = src.fBounds.width();
     src.fImage = SkMask::AllocImage(src.computeTotalImageSize());
 
     memset(src.fImage, 0xff, src.computeTotalImageSize());
 
-    dst.fImage = NULL;
+    dst.fImage = nullptr;
     SkBlurMask::BlurGroundTruth(sigma, &dst, src, kNormal_SkBlurStyle);
 
     int midX = dst.fBounds.centerX();
     int midY = dst.fBounds.centerY();
     uint8_t* bytes = dst.getAddr8(midX, midY);
     int i;
     for (i = 0; i < dst.fBounds.width()-(midX-dst.fBounds.fLeft); ++i) {
         if (i < resultCount) {
             result[i] = bytes[i];
         }
@@ skipping 89 matching lines @@
 }
 
 #if SK_SUPPORT_GPU
 #if 0
 // temporary disable; see below for explanation
 static bool gpu_blur_path(GrContextFactory* factory, const SkPath& path,
                           SkScalar gaussianSigma,
                           int* result, int resultCount) {
 
     GrContext* grContext = factory->get(GrContextFactory::kNative_GLContextType);
-    if (NULL == grContext) {
+    if (nullptr == grContext) {
         return false;
     }
 
     GrSurfaceDesc desc;
     desc.fConfig = kSkia8888_GrPixelConfig;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = resultCount;
     desc.fHeight = 30;
     desc.fSampleCnt = 0;
 
-    SkAutoTUnref<GrTexture> texture(grContext->createTexture(desc, false, NULL, 0));
+    SkAutoTUnref<GrTexture> texture(grContext->createTexture(desc, false, nullptr, 0));
     SkAutoTUnref<SkGpuDevice> device(new SkGpuDevice  (grContext, texture.get()));
     SkCanvas canvas(device.get());
 
     blur_path(&canvas, path, gaussianSigma);
     readback(&canvas, result, resultCount);
     return true;
 }
 #endif
 #endif
 
@@ skipping 117 matching lines @@
     const SkScalar dx = 10;
     const SkScalar dy = -5;
     const SkBlurQuality quality = blurMaskFilterFlags_as_quality(blurMaskFilterFlags);
     uint32_t flags = blurMaskFilterFlags_to_blurDrawLooperFlags(blurMaskFilterFlags);
 
     SkAutoTUnref<SkDrawLooper> lp(SkBlurDrawLooper::Create(color, sigma, dx, dy, flags));
 
     const bool expectSuccess = sigma > 0 &&
                                0 == (flags & SkBlurDrawLooper::kIgnoreTransform_BlurFlag);
 
-    if (NULL == lp.get()) {
+    if (nullptr == lp.get()) {
         REPORTER_ASSERT(reporter, sigma <= 0);
     } else {
         SkDrawLooper::BlurShadowRec rec;
         bool success = lp->asABlurShadow(&rec);
         REPORTER_ASSERT(reporter, success == expectSuccess);
         if (success) {
             REPORTER_ASSERT(reporter, rec.fSigma == sigma);
             REPORTER_ASSERT(reporter, rec.fOffset.x() == dx);
             REPORTER_ASSERT(reporter, rec.fOffset.y() == dy);
             REPORTER_ASSERT(reporter, rec.fColor == color);
@@ skipping 75 matching lines @@
     // Test asABlur for SkBlurMaskFilter
     //
     for (size_t i = 0; i < SK_ARRAY_COUNT(styles); ++i) {
         const SkBlurStyle style = (SkBlurStyle)styles[i];
         for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
             const SkScalar sigma = sigmas[j];
             for (int flags = 0; flags <= SkBlurMaskFilter::kAll_BlurFlag; ++flags) {
                 const SkBlurQuality quality = blurMaskFilterFlags_as_quality(flags);
 
                 SkAutoTUnref<SkMaskFilter> mf(SkBlurMaskFilter::Create(style, sigma, flags));
-                if (NULL == mf.get()) {
+                if (nullptr == mf.get()) {
                     REPORTER_ASSERT(reporter, sigma <= 0);
                 } else {
                     REPORTER_ASSERT(reporter, sigma > 0);
                     SkMaskFilter::BlurRec rec;
                     bool success = mf->asABlur(&rec);
                     if (flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) {
                         REPORTER_ASSERT(reporter, !success);
                     } else {
                         REPORTER_ASSERT(reporter, success);
                         REPORTER_ASSERT(reporter, rec.fSigma == sigma);
@@ skipping 25 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 DEF_GPUTEST(Blur, reporter, factory) {
     test_blur_drawing(reporter);
     test_sigma_range(reporter, factory);
     test_asABlur(reporter);
 }