Style Change: NULL->nullptr

tests/WritePixelsTest.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 "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkMathPriv.h"
@@ skipping 182 matching lines @@
     // Can't use canvas->peekPixels(), as we are trying to look at GPU pixels sometimes as well.
     // At some point this will be unsupported, as we won't allow accessBitmap() to magically call
     // readPixels for the client.
     SkBitmap secretDevBitmap;
     canvas->readPixels(canvasInfo.bounds(), &secretDevBitmap);
 
     SkAutoLockPixels alp(secretDevBitmap);
     canvasRowBytes = secretDevBitmap.rowBytes();
     canvasPixels = static_cast<const uint32_t*>(secretDevBitmap.getPixels());
 
-    if (NULL == canvasPixels) {
+    if (nullptr == canvasPixels) {
         return false;
     }
 
     if (canvasInfo.width() != DEV_W ||
         canvasInfo.height() != DEV_H ||
         canvasInfo.colorType() != kN32_SkColorType) {
         return false;
     }
 
     const SkImageInfo bmInfo = bitmap.info();
@@ skipping 65 matching lines @@
 #include "SkMallocPixelRef.h"
 
 // This is a tricky pattern, because we have to setConfig+rowBytes AND specify
 // a custom pixelRef (which also has to specify its rowBytes), so we have to be
 // sure that the two rowBytes match (and the infos match).
 //
 static bool alloc_row_bytes(SkBitmap* bm, const SkImageInfo& info, size_t rowBytes) {
     if (!bm->setInfo(info, rowBytes)) {
         return false;
     }
-    SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, rowBytes, NULL);
+    SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, rowBytes, nullptr);
     bm->setPixelRef(pr)->unref();
     return true;
 }
 
 static void free_pixels(void* pixels, void* ctx) {
     sk_free(pixels);
 }
 
 static SkSurface* create_surface(const CanvasConfig& c, GrContext* grCtx) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
     switch (c.fDevType) {
         case kRaster_DevType: {
             const size_t rowBytes = c.fTightRowBytes ? info.minRowBytes() : 4 * DEV_W + 100;
             const size_t size = info.getSafeSize(rowBytes);
             void* pixels = sk_malloc_throw(size);
             // if rowBytes isn't tight then set the padding to a known value
             if (!c.fTightRowBytes) {
                 memset(pixels, DEV_PAD, size);
             }
-            return SkSurface::NewRasterDirectReleaseProc(info, pixels, rowBytes, free_pixels, NULL);
+            return SkSurface::NewRasterDirectReleaseProc(info, pixels, rowBytes, free_pixels, nullptr);
         }
 #if SK_SUPPORT_GPU
         case kGpu_BottomLeft_DevType:
         case kGpu_TopLeft_DevType:
             GrSurfaceDesc desc;
             desc.fFlags = kRenderTarget_GrSurfaceFlag;
             desc.fWidth = DEV_W;
             desc.fHeight = DEV_H;
             desc.fConfig = kSkia8888_GrPixelConfig;
             desc.fOrigin = kGpu_TopLeft_DevType == c.fDevType ?
                 kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
             SkAutoTUnref<GrTexture> texture(grCtx->textureProvider()->createTexture(desc, false));
             return SkSurface::NewRenderTargetDirect(texture->asRenderTarget());
 #endif
     }
-    return NULL;
+    return nullptr;
 }
 
 static bool setup_bitmap(SkBitmap* bm, SkColorType ct, SkAlphaType at, int w, int h, int tightRB) {
     size_t rowBytes = tightRB ? 0 : 4 * w + 60;
     SkImageInfo info = SkImageInfo::Make(w, h, ct, at);
     if (!alloc_row_bytes(bm, info, rowBytes)) {
         return false;
     }
     SkAutoLockPixels alp(*bm);
     for (int y = 0; y < h; ++y) {
@@ skipping 74 matching lines @@
     for (size_t i = 0; i < SK_ARRAY_COUNT(gCanvasConfigs); ++i) {
         int glCtxTypeCnt = 1;
 #if SK_SUPPORT_GPU
         bool isGPUDevice = kGpu_TopLeft_DevType == gCanvasConfigs[i].fDevType ||
                            kGpu_BottomLeft_DevType == gCanvasConfigs[i].fDevType;
         if (isGPUDevice) {
             glCtxTypeCnt = GrContextFactory::kGLContextTypeCnt;
         }
 #endif
         for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
-            GrContext* context = NULL;
+            GrContext* context = nullptr;
 #if SK_SUPPORT_GPU
             if (isGPUDevice) {
                 GrContextFactory::GLContextType type =
                     static_cast<GrContextFactory::GLContextType>(glCtxType);
                 if (!GrContextFactory::IsRenderingGLContext(type)) {
                     continue;
                 }
                 context = factory->get(type);
-                if (NULL == context) {
+                if (nullptr == context) {
                     continue;
                 }
             }
 #endif
 
             SkAutoTUnref<SkSurface> surface(create_surface(gCanvasConfigs[i], context));
             SkCanvas& canvas = *surface->getCanvas();
 
             static const struct {
                 SkColorType fColorType;
@@ skipping 29 matching lines @@
                         SkIRect writeRect = SkIRect::MakeXYWH(rect.fLeft, rect.fTop,
                                                               bmp.width(), bmp.height());
                         bool intersects = SkIRect::Intersects(canvasRect, writeRect) ;
                         REPORTER_ASSERT(reporter, intersects == (idBefore != idAfter));
                     }
                 }
             }
         }
     }
 }