Style Change: NULL->nullptr

tests/SurfaceTest.cpp

 /*
  * Copyright 2013 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 "SkData.h"
 #include "SkDevice.h"
@@ skipping 23 matching lines @@
 };
 static const int kSurfaceTypeCnt = kLastSurfaceType + 1;
 
 static void release_storage(void* pixels, void* context) {
     SkASSERT(pixels == context);
     sk_free(pixels);
 }
 
 static SkSurface* create_surface(SurfaceType surfaceType, GrContext* context,
                                  SkAlphaType at = kPremul_SkAlphaType,
-                                 SkImageInfo* requestedInfo = NULL) {
+                                 SkImageInfo* requestedInfo = nullptr) {
     const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
 
     if (requestedInfo) {
         *requestedInfo = info;
     }
 
     switch (surfaceType) {
         case kRaster_SurfaceType:
             return SkSurface::NewRaster(info);
         case kRasterDirect_SurfaceType: {
             const size_t rowBytes = info.minRowBytes();
             void* storage = sk_malloc_throw(info.getSafeSize(rowBytes));
             return SkSurface::NewRasterDirectReleaseProc(info, storage, rowBytes,
                                                          release_storage, storage);
         }
         case kGpu_SurfaceType:
-            return SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, NULL);
+            return SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, nullptr);
         case kGpuScratch_SurfaceType:
-            return SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted, info, 0, NULL);
+            return SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted, info, 0, nullptr);
     }
-    return NULL;
+    return nullptr;
 }
 
 enum ImageType {
     kRasterCopy_ImageType,
     kRasterData_ImageType,
     kRasterProc_ImageType,
     kGpu_ImageType,
     kCodec_ImageType,
 };
 
 #include "SkImageGenerator.h"
 
 class EmptyGenerator : public SkImageGenerator {
 public:
     EmptyGenerator() : SkImageGenerator(SkImageInfo::MakeN32Premul(0, 0)) {}
 };
 
 static void test_empty_image(skiatest::Reporter* reporter) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     
-    REPORTER_ASSERT(reporter, NULL == SkImage::NewRasterCopy(info, NULL, 0));
-    REPORTER_ASSERT(reporter, NULL == SkImage::NewRasterData(info, NULL, 0));
-    REPORTER_ASSERT(reporter, NULL == SkImage::NewFromRaster(info, NULL, 0, NULL, NULL));
-    REPORTER_ASSERT(reporter, NULL == SkImage::NewFromGenerator(new EmptyGenerator));
+    REPORTER_ASSERT(reporter, nullptr == SkImage::NewRasterCopy(info, nullptr, 0));
+    REPORTER_ASSERT(reporter, nullptr == SkImage::NewRasterData(info, nullptr, 0));
+    REPORTER_ASSERT(reporter, nullptr == SkImage::NewFromRaster(info, nullptr, 0, nullptr, nullptr));
+    REPORTER_ASSERT(reporter, nullptr == SkImage::NewFromGenerator(new EmptyGenerator));
 }
 
 static void test_empty_surface(skiatest::Reporter* reporter, GrContext* ctx) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     
-    REPORTER_ASSERT(reporter, NULL == SkSurface::NewRaster(info));
-    REPORTER_ASSERT(reporter, NULL == SkSurface::NewRasterDirect(info, NULL, 0));
+    REPORTER_ASSERT(reporter, nullptr == SkSurface::NewRaster(info));
+    REPORTER_ASSERT(reporter, nullptr == SkSurface::NewRasterDirect(info, nullptr, 0));
     if (ctx) {
-        REPORTER_ASSERT(reporter, NULL ==
-                        SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info, 0, NULL));
+        REPORTER_ASSERT(reporter, nullptr ==
+                        SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info, 0, nullptr));
     }
 }
 
 #if SK_SUPPORT_GPU
 static void test_wrapped_texture_surface(skiatest::Reporter* reporter, GrContext* ctx) {
-    if (NULL == ctx) {
+    if (nullptr == ctx) {
         return;
     }
 
     const GrGpu* gpu = ctx->getGpu();
     if (!gpu) {
         return;
     }
 
     // Test the wrapped factory for SkSurface by creating a backend texture and then wrap it in
     // a SkSurface.
     static const int kW = 100;
     static const int kH = 100;
     static const uint32_t kOrigColor = 0xFFAABBCC;
     SkAutoTArray<uint32_t> pixels(kW * kH);
     sk_memset32(pixels.get(), kOrigColor, kW * kH);
     GrBackendObject texID = gpu->createTestingOnlyBackendTexture(pixels.get(), kW, kH,
                                                                  kRGBA_8888_GrPixelConfig);
 
     GrBackendTextureDesc wrappedDesc;
     wrappedDesc.fConfig = kRGBA_8888_GrPixelConfig;
     wrappedDesc.fWidth = kW;
     wrappedDesc.fHeight = kH;
     wrappedDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
     wrappedDesc.fSampleCnt = 0;
     wrappedDesc.fFlags = kRenderTarget_GrBackendTextureFlag;
     wrappedDesc.fTextureHandle = texID;
 
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewWrappedRenderTarget(ctx, wrappedDesc, NULL));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewWrappedRenderTarget(ctx, wrappedDesc, nullptr));
     REPORTER_ASSERT(reporter, surface);
     if (surface) {
         // Validate that we can draw to the canvas and that the original texture color is preserved
         // in pixels that aren't rendered to via the surface.
         SkPaint paint;
         static const SkColor kRectColor = ~kOrigColor | 0xFF000000;
         paint.setColor(kRectColor);
         surface->getCanvas()->drawRect(SkRect::MakeWH(SkIntToScalar(kW), SkIntToScalar(kH)/2),
                                        paint);
         SkImageInfo readInfo = SkImageInfo::MakeN32Premul(kW, kH);
@@ skipping 45 matching lines @@
 
 // Want to ensure that our Release is called when the owning image is destroyed
 struct ReleaseDataContext {
     skiatest::Reporter* fReporter;
     SkData*             fData;
 
     static void Release(const void* pixels, void* context) {
         ReleaseDataContext* state = (ReleaseDataContext*)context;
         REPORTER_ASSERT(state->fReporter, state->fData);
         state->fData->unref();
-        state->fData = NULL;
+        state->fData = nullptr;
     }
 };
 
 // May we (soon) eliminate the need to keep testing this, by hiding the bloody device!
 #include "SkDevice.h"
 static uint32_t get_legacy_gen_id(SkSurface* surf) {
     SkBaseDevice* device = surf->getCanvas()->getDevice_just_for_deprecated_compatibility_testing();
     return device->accessBitmap(false).getGenerationID();
 }
 
@@ skipping 90 matching lines @@
         }
         case kCodec_ImageType: {
             SkBitmap bitmap;
             bitmap.installPixels(info, addr, rowBytes);
             SkAutoTUnref<SkData> src(
                  SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
             return SkImage::NewFromEncoded(src);
         }
     }
     SkASSERT(false);
-    return NULL;
+    return nullptr;
 }
 
 static void set_pixels(SkPMColor pixels[], int count, SkPMColor color) {
     sk_memset32(pixels, color, count);
 }
 static bool has_pixels(const SkPMColor pixels[], int count, SkPMColor expected) {
     for (int i = 0; i < count; ++i) {
         if (pixels[i] != expected) {
             return false;
         }
@@ skipping 97 matching lines @@
         { kRasterCopy_ImageType,    true,       "RasterCopy"    },
         { kRasterData_ImageType,    true,       "RasterData"    },
         { kRasterProc_ImageType,    true,       "RasterProc"    },
         { kGpu_ImageType,           false,      "Gpu"           },
         { kCodec_ImageType,         false,      "Codec"         },
     };
 
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
 
-    GrContext* ctx = NULL;
+    GrContext* ctx = nullptr;
 #if SK_SUPPORT_GPU
     ctx = factory->get(GrContextFactory::kNative_GLContextType);
-    if (NULL == ctx) {
+    if (nullptr == ctx) {
         return;
     }
 #endif
 
     ReleaseDataContext releaseCtx;
     releaseCtx.fReporter = reporter;
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         SkImageInfo info;
         size_t rowBytes;
 
-        releaseCtx.fData = NULL;
+        releaseCtx.fData = nullptr;
         SkAutoTUnref<SkImage> image(create_image(reporter, gRec[i].fType, ctx, color, &releaseCtx));
         if (!image.get()) {
             SkDebugf("failed to createImage[%d] %s\n", i, gRec[i].fName);
             continue;   // gpu may not be enabled
         }
         if (kRasterProc_ImageType == gRec[i].fType) {
-            REPORTER_ASSERT(reporter, NULL != releaseCtx.fData);  // we are tracking the data
+            REPORTER_ASSERT(reporter, nullptr != releaseCtx.fData);  // we are tracking the data
         } else {
-            REPORTER_ASSERT(reporter, NULL == releaseCtx.fData);  // we ignored the context
+            REPORTER_ASSERT(reporter, nullptr == releaseCtx.fData);  // we ignored the context
         }
 
         test_legacy_bitmap(reporter, image);
 
         const void* addr = image->peekPixels(&info, &rowBytes);
         bool success = SkToBool(addr);
         REPORTER_ASSERT(reporter, gRec[i].fPeekShouldSucceed == success);
         if (success) {
             REPORTER_ASSERT(reporter, 10 == info.width());
             REPORTER_ASSERT(reporter, 10 == info.height());
             REPORTER_ASSERT(reporter, kN32_SkColorType == info.colorType());
             REPORTER_ASSERT(reporter, kPremul_SkAlphaType == info.alphaType() ||
                             kOpaque_SkAlphaType == info.alphaType());
             REPORTER_ASSERT(reporter, info.minRowBytes() <= rowBytes);
             REPORTER_ASSERT(reporter, pmcolor == *(const SkPMColor*)addr);
         }
 
         test_image_readpixels(reporter, image, pmcolor);
     }
-    REPORTER_ASSERT(reporter, NULL == releaseCtx.fData);  // we released the data
+    REPORTER_ASSERT(reporter, nullptr == releaseCtx.fData);  // we released the data
 }
 
 static void test_canvaspeek(skiatest::Reporter* reporter,
                             GrContextFactory* factory) {
     static const struct {
         SurfaceType fType;
         bool        fPeekShouldSucceed;
     } gRec[] = {
         { kRaster_SurfaceType,          true    },
         { kRasterDirect_SurfaceType,    true    },
 #if SK_SUPPORT_GPU
         { kGpu_SurfaceType,             false   },
         { kGpuScratch_SurfaceType,      false   },
 #endif
     };
 
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
 
     int cnt;
 #if SK_SUPPORT_GPU
     cnt = GrContextFactory::kGLContextTypeCnt;
 #else
     cnt = 1;
 #endif
 
     for (int i= 0; i < cnt; ++i) {
-        GrContext* context = NULL;
+        GrContext* context = nullptr;
 #if SK_SUPPORT_GPU
         GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
         if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
             continue;
         }
         context = factory->get(glCtxType);
 
-        if (NULL == context) {
+        if (nullptr == context) {
             continue;
         }
 #endif
         for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
             SkImageInfo info, requestInfo;
             size_t rowBytes;
 
             SkAutoTUnref<SkSurface> surface(create_surface(gRec[i].fType, context,
                                                            kPremul_SkAlphaType, &requestInfo));
             surface->getCanvas()->clear(color);
 
             const void* addr = surface->getCanvas()->peekPixels(&info, &rowBytes);
             bool success = SkToBool(addr);
             REPORTER_ASSERT(reporter, gRec[i].fPeekShouldSucceed == success);
 
             SkImageInfo info2;
             size_t rb2;
             const void* addr2 = surface->peekPixels(&info2, &rb2);
 
             if (success) {
                 REPORTER_ASSERT(reporter, requestInfo == info);
                 REPORTER_ASSERT(reporter, requestInfo.minRowBytes() <= rowBytes);
                 REPORTER_ASSERT(reporter, pmcolor == *(const SkPMColor*)addr);
 
                 REPORTER_ASSERT(reporter, addr2 == addr);
                 REPORTER_ASSERT(reporter, info2 == info);
                 REPORTER_ASSERT(reporter, rb2 == rowBytes);
             } else {
-                REPORTER_ASSERT(reporter, NULL == addr2);
+                REPORTER_ASSERT(reporter, nullptr == addr2);
             }
         }
     }
 }
 
 // For compatibility with clients that still call accessBitmap(), we need to ensure that we bump
 // the bitmap's genID when we draw to it, else they won't know it has new values. When they are
 // exclusively using surface/image, and we can hide accessBitmap from device, we can remove this
 // test.
 static void test_accessPixels(skiatest::Reporter* reporter, GrContextFactory* factory) {
@@ skipping 10 matching lines @@
     };
     
     int cnt;
 #if SK_SUPPORT_GPU
     cnt = GrContextFactory::kGLContextTypeCnt;
 #else
     cnt = 1;
 #endif
     
     for (int i= 0; i < cnt; ++i) {
-        GrContext* context = NULL;
+        GrContext* context = nullptr;
 #if SK_SUPPORT_GPU
         GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
         if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
             continue;
         }
         context = factory->get(glCtxType);
         
-        if (NULL == context) {
+        if (nullptr == context) {
             continue;
         }
 #endif
         for (size_t j = 0; j < SK_ARRAY_COUNT(gRec); ++j) {
             SkImageInfo info, requestInfo;
             
             SkAutoTUnref<SkSurface> surface(create_surface(gRec[j].fType, context,
                                                            kPremul_SkAlphaType,  &requestInfo));
             SkCanvas* canvas = surface->getCanvas();
             canvas->clear(0);
 
             SkBaseDevice* device = canvas->getDevice_just_for_deprecated_compatibility_testing();
             SkBitmap bm = device->accessBitmap(false);
             uint32_t genID0 = bm.getGenerationID();
             // Now we draw something, which needs to "dirty" the genID (sorta like copy-on-write)
             canvas->drawColor(SK_ColorBLUE);
             // Now check that we get a different genID
             uint32_t genID1 = bm.getGenerationID();
             REPORTER_ASSERT(reporter, genID0 != genID1);
         }
     }
 }
 
 static void test_snap_alphatype(skiatest::Reporter* reporter, GrContextFactory* factory) {
-    GrContext* context = NULL;
+    GrContext* context = nullptr;
 #if SK_SUPPORT_GPU
     context = factory->get(GrContextFactory::kNative_GLContextType);
-    if (NULL == context) {
+    if (nullptr == context) {
         return;
     }
 #endif
     for (int opaque = 0; opaque < 2; ++opaque) {
         SkAlphaType atype = SkToBool(opaque) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
         for (int st = 0; st < kSurfaceTypeCnt; ++st) {
             SurfaceType stype = (SurfaceType)st;
             SkAutoTUnref<SkSurface> surface(create_surface(stype, context, atype));
             REPORTER_ASSERT(reporter, surface);
             if (surface) {
@@ skipping 84 matching lines @@
     EXPECT_COPY_ON_WRITE(clear(testColor))
     EXPECT_COPY_ON_WRITE(drawPaint(testPaint))
     EXPECT_COPY_ON_WRITE(drawPoints(SkCanvas::kPoints_PointMode, testPointCount, testPoints, \
         testPaint))
     EXPECT_COPY_ON_WRITE(drawOval(testRect, testPaint))
     EXPECT_COPY_ON_WRITE(drawRect(testRect, testPaint))
     EXPECT_COPY_ON_WRITE(drawRRect(testRRect, testPaint))
     EXPECT_COPY_ON_WRITE(drawPath(testPath, testPaint))
     EXPECT_COPY_ON_WRITE(drawBitmap(testBitmap, 0, 0))
     EXPECT_COPY_ON_WRITE(drawBitmapRect(testBitmap, testRect, nullptr))
-    EXPECT_COPY_ON_WRITE(drawBitmapNine(testBitmap, testIRect, testRect, NULL))
-    EXPECT_COPY_ON_WRITE(drawSprite(testBitmap, 0, 0, NULL))
+    EXPECT_COPY_ON_WRITE(drawBitmapNine(testBitmap, testIRect, testRect, nullptr))
+    EXPECT_COPY_ON_WRITE(drawSprite(testBitmap, 0, 0, nullptr))
     EXPECT_COPY_ON_WRITE(drawText(testText.c_str(), testText.size(), 0, 1, testPaint))
     EXPECT_COPY_ON_WRITE(drawPosText(testText.c_str(), testText.size(), testPoints2, \
         testPaint))
-    EXPECT_COPY_ON_WRITE(drawTextOnPath(testText.c_str(), testText.size(), testPath, NULL, \
+    EXPECT_COPY_ON_WRITE(drawTextOnPath(testText.c_str(), testText.size(), testPath, nullptr, \
         testPaint))
 
     const SkSurface::BackendHandleAccess accessModes[] = {
         SkSurface::kFlushRead_BackendHandleAccess,
         SkSurface::kFlushWrite_BackendHandleAccess,
         SkSurface::kDiscardWrite_BackendHandleAccess,
     };
 
     for (auto access : accessModes) {
         test_backend_cow(reporter, surface, access,
@@ skipping 64 matching lines @@
 static void TestGetTexture(skiatest::Reporter* reporter,
                                  SurfaceType surfaceType,
                                  GrContext* context) {
     SkAutoTUnref<SkSurface> surface(create_surface(surfaceType, context));
     SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
     GrTexture* texture = as_IB(image)->getTexture();
     if (surfaceType == kGpu_SurfaceType || surfaceType == kGpuScratch_SurfaceType) {
         REPORTER_ASSERT(reporter, texture);
         REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle());
     } else {
-        REPORTER_ASSERT(reporter, NULL == texture);
+        REPORTER_ASSERT(reporter, nullptr == texture);
     }
     surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
     REPORTER_ASSERT(reporter, as_IB(image)->getTexture() == texture);
 }
 
 #include "GrGpuResourcePriv.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Gpu.h"
 #include "SkSurface_Gpu.h"
 
@@ skipping 66 matching lines @@
         SkDEBUGCODE(image2->validate();)
         SkDEBUGCODE(surface->validate();)
         REPORTER_ASSERT(reporter, image1 != image2);
     }
 
 }
 
 DEF_GPUTEST(Surface, reporter, factory) {
     test_image(reporter);
 
-    TestSurfaceCopyOnWrite(reporter, kRaster_SurfaceType, NULL);
-    TestSurfaceWritableAfterSnapshotRelease(reporter, kRaster_SurfaceType, NULL);
-    TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kDiscard_ContentChangeMode);
-    TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kRetain_ContentChangeMode);
+    TestSurfaceCopyOnWrite(reporter, kRaster_SurfaceType, nullptr);
+    TestSurfaceWritableAfterSnapshotRelease(reporter, kRaster_SurfaceType, nullptr);
+    TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, nullptr, SkSurface::kDiscard_ContentChangeMode);
+    TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, nullptr, SkSurface::kRetain_ContentChangeMode);
 
     test_empty_image(reporter);
-    test_empty_surface(reporter, NULL);
+    test_empty_surface(reporter, nullptr);
 
     test_imagepeek(reporter, factory);
     test_canvaspeek(reporter, factory);
 
     test_accessPixels(reporter, factory);
 
     test_snap_alphatype(reporter, factory);
 
 #if SK_SUPPORT_GPU
-    TestGetTexture(reporter, kRaster_SurfaceType, NULL);
+    TestGetTexture(reporter, kRaster_SurfaceType, nullptr);
     if (factory) {
         for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
             GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
             if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
                 continue;
             }
             GrContext* context = factory->get(glCtxType);
             if (context) {
                 Test_crbug263329(reporter, kGpu_SurfaceType, context);
                 Test_crbug263329(reporter, kGpuScratch_SurfaceType, context);
@@ skipping 85 matching lines @@
     SkAutoTUnref<GrTexture> tex(provider->createTexture(desc, false, storage, w * 4));
     if (!tex) {
         REPORTER_ASSERT(reporter, false);
         return;
     }
 
     GrBackendObject srcTex = tex->getTextureHandle();
     ReleaseTextureContext releaseCtx(reporter);
 
     SkAutoTUnref<SkImage> refImg(make_desc_image(ctx, w, h, srcTex, &releaseCtx));
-    SkAutoTUnref<SkImage> cpyImg(make_desc_image(ctx, w, h, srcTex, NULL));
+    SkAutoTUnref<SkImage> cpyImg(make_desc_image(ctx, w, h, srcTex, nullptr));
 
     test_image_color(reporter, refImg, expected0);
     test_image_color(reporter, cpyImg, expected0);
 
     // Now lets jam new colors into our "external" texture, and see if the images notice
     const SkPMColor expected1 = SkPreMultiplyColor(SK_ColorBLUE);
     sk_memset32(storage, expected1, w * h);
     tex->writePixels(0, 0, w, h, kSkia8888_GrPixelConfig, storage, GrContext::kFlushWrites_PixelOp);
 
     // The cpy'd one should still see the old color
 #if 0
     // There is no guarantee that refImg sees the new color. We are free to have made a copy. Our
     // write pixels call violated the contract with refImg and refImg is now undefined.
     test_image_color(reporter, refImg, expected1);
 #endif
     test_image_color(reporter, cpyImg, expected0);
 
     // Now exercise the release proc
     REPORTER_ASSERT(reporter, !releaseCtx.fIsReleased);
-    refImg.reset(NULL); // force a release of the image
+    refImg.reset(nullptr); // force a release of the image
     REPORTER_ASSERT(reporter, releaseCtx.fIsReleased);
 }
 #endif