Style Change: NULL->nullptr

tests/CanvasTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*  Description:
  *      This test defines a series of elementatry test steps that perform
  *      a single or a small group of canvas API calls. Each test step is
@@ skipping 197 matching lines @@
 
     Canvas2CanvasClipVisitor visitor(&c);
     canvas->replayClips(&visitor);
 
     REPORTER_ASSERT(reporter, equal_clips(c, *canvas));
 }
 
 static void test_clipstack(skiatest::Reporter* reporter) {
     // The clipstack is refcounted, and needs to be able to out-live the canvas if a client has
     // ref'd it.
-    const SkClipStack* cs = NULL;
+    const SkClipStack* cs = nullptr;
     {
         SkCanvas canvas(10, 10);
         cs = SkRef(canvas.getClipStack());
     }
     REPORTER_ASSERT(reporter, cs->unique());
     cs->unref();
 }
 
 // Format strings that describe the test context.  The %s token is where
 // the name of the test step is inserted.  The context is required for
@@ skipping 120 matching lines @@
         testStep->assertMessage());
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalMatrix().isIdentity(),
         testStep->assertMessage());
 //    REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalClip() != kTestRegion, testStep->assertMessage());
 }
 TEST_STEP(SaveMatrixClip, SaveMatrixClipStep);
 
 static void SaveLayerStep(SkCanvas* canvas, const TestData& d,
                           skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
-    canvas->saveLayer(NULL, NULL);
+    canvas->saveLayer(nullptr, nullptr);
     canvas->restore();
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(SaveLayer, SaveLayerStep);
 
 static void BoundedSaveLayerStep(SkCanvas* canvas, const TestData& d,
                                  skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
-    canvas->saveLayer(&d.fRect, NULL);
+    canvas->saveLayer(&d.fRect, nullptr);
     canvas->restore();
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(BoundedSaveLayer, BoundedSaveLayerStep);
 
 static void PaintSaveLayerStep(SkCanvas* canvas, const TestData& d,
                                skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
-    canvas->saveLayer(NULL, &d.fPaint);
+    canvas->saveLayer(nullptr, &d.fPaint);
     canvas->restore();
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(PaintSaveLayer, PaintSaveLayerStep);
 
 static void TwoClipOpsStep(SkCanvas* canvas, const TestData& d,
                            skiatest::Reporter*, CanvasTestStep*) {
     // This test exercises a functionality in SkPicture that leads to the
     // recording of restore offset placeholders.  This test will trigger an
@@ skipping 21 matching lines @@
     SkPoint pts[4];
     pts[0].set(0, 0);
     pts[1].set(SkIntToScalar(d.fWidth), 0);
     pts[2].set(SkIntToScalar(d.fWidth), SkIntToScalar(d.fHeight));
     pts[3].set(0, SkIntToScalar(d.fHeight));
     SkPaint paint;
     SkShader* shader = SkShader::CreateBitmapShader(d.fBitmap,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     paint.setShader(shader)->unref();
     canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, pts, pts,
-                         NULL, NULL, NULL, 0, paint);
+                         nullptr, nullptr, nullptr, 0, paint);
 }
 // NYI: issue 240.
 TEST_STEP_NO_PDF(DrawVerticesShader, DrawVerticesShaderTestStep);
 
 static void DrawPictureTestStep(SkCanvas* canvas, const TestData& d,
                                 skiatest::Reporter*, CanvasTestStep*) {
     SkPictureRecorder recorder;
     SkCanvas* testCanvas = recorder.beginRecording(SkIntToScalar(d.fWidth), SkIntToScalar(d.fHeight),
-                                                   NULL, 0);
+                                                   nullptr, 0);
     testCanvas->scale(SkIntToScalar(2), SkIntToScalar(1));
     testCanvas->clipRect(d.fRect);
     testCanvas->drawRect(d.fRect, d.fPaint);
     SkAutoTUnref<SkPicture> testPicture(recorder.endRecording());
 
     canvas->drawPicture(testPicture);
 }
 TEST_STEP(DrawPicture, DrawPictureTestStep);
 
 static void SaveRestoreTestStep(SkCanvas* canvas, const TestData& d,
@@ skipping 210 matching lines @@
     for (int y = 0; y < info.height(); ++y) {
         for (int x = 0; x < info.width(); ++x) {
             REPORTER_ASSERT(reporter, 0 == addr[x]);
         }
         addr = (const SkPMColor*)((const char*)addr + rowBytes);
     }
     delete canvas;
 
     // now try a deliberately bad info
     info = info.makeWH(-1, info.height());
-    REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
+    REPORTER_ASSERT(reporter, nullptr == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
 
     // too big
     info = info.makeWH(1 << 30, 1 << 30);
-    REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
+    REPORTER_ASSERT(reporter, nullptr == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
 
     // not a valid pixel type
     info = SkImageInfo::Make(10, 10, kUnknown_SkColorType, info.alphaType());
-    REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
+    REPORTER_ASSERT(reporter, nullptr == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
 
     // We should succeed with a zero-sized valid info
     info = SkImageInfo::MakeN32Premul(0, 0);
     canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
     REPORTER_ASSERT(reporter, canvas);
     delete canvas;
 }
 
 DEF_TEST(Canvas, reporter) {
     TestData d;
 
     for (int testStep = 0; testStep < testStepArray().count(); testStep++) {
         TestOverrideStateConsistency(reporter, d, testStepArray()[testStep]);
         if (testStepArray()[testStep]->enablePdfTesting()) {
             TestPdfDevice(reporter, d, testStepArray()[testStep]);
         }
     }
 
     test_newraster(reporter);
 }
 
 DEF_TEST(Canvas_SaveState, reporter) {
     SkCanvas canvas(10, 10);
     REPORTER_ASSERT(reporter, 1 == canvas.getSaveCount());
 
     int n = canvas.save();
     REPORTER_ASSERT(reporter, 1 == n);
     REPORTER_ASSERT(reporter, 2 == canvas.getSaveCount());
 
-    n = canvas.saveLayer(NULL, NULL);
+    n = canvas.saveLayer(nullptr, nullptr);
     REPORTER_ASSERT(reporter, 2 == n);
     REPORTER_ASSERT(reporter, 3 == canvas.getSaveCount());
     
     canvas.restore();
     REPORTER_ASSERT(reporter, 2 == canvas.getSaveCount());
     canvas.restore();
     REPORTER_ASSERT(reporter, 1 == canvas.getSaveCount());
 }
 
 DEF_TEST(Canvas_ClipEmptyPath, reporter) {
@@ skipping 39 matching lines @@
     REPORTER_ASSERT(reporter, canvas.getTotalMatrix() == filterCanvas.getTotalMatrix());
     REPORTER_ASSERT(reporter, canvas.getClipBounds(&clip1) == filterCanvas.getClipBounds(&clip2));
     REPORTER_ASSERT(reporter, clip1 == clip2);
 
     filterCanvas.clipRect(SkRect::MakeXYWH(30.5f, 30.7f, 100, 100));
     filterCanvas.scale(0.75f, 0.5f);
     REPORTER_ASSERT(reporter, canvas.getTotalMatrix() == filterCanvas.getTotalMatrix());
     REPORTER_ASSERT(reporter, canvas.getClipBounds(&clip1) == filterCanvas.getClipBounds(&clip2));
     REPORTER_ASSERT(reporter, clip1 == clip2);
 }