Style Change: NULL->nullptr

tests/PictureTest.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.
  */
 
 #include "SkBBoxHierarchy.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
@@ skipping 145 matching lines @@
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setPathEffect(dash);
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     // path effects currently render an SkPicture undesireable for GPU rendering
 
-    const char *reason = NULL;
-    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL, &reason));
+    const char *reason = nullptr;
+    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr, &reason));
     REPORTER_ASSERT(reporter, reason);
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 50);
         path.lineTo(25, 25);
         path.lineTo(50, 50);
         path.lineTo(50, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture.reset(recorder.endRecording());
     // A lot of small AA concave paths should be fine for GPU rendering
-    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL));
+    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 100);
         path.lineTo(50, 50);
         path.lineTo(100, 100);
         path.lineTo(100, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture.reset(recorder.endRecording());
     // A lot of large AA concave paths currently render an SkPicture undesireable for GPU rendering
-    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
+    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 50);
         path.lineTo(25, 25);
         path.lineTo(50, 50);
         path.lineTo(50, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(0);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture.reset(recorder.endRecording());
     // hairline stroked AA concave paths are fine for GPU rendering
-    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL));
+    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         SkScalar intervals [] = { 10, 20 };
         SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25);
         paint.setPathEffect(pe)->unref();
 
         SkPoint points [2] = { { 0, 0 }, { 100, 0 } };
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawPoints(SkCanvas::kLines_PointMode, 2, points, paint);
         }
     }
     picture.reset(recorder.endRecording());
     // fast-path dashed effects are fine for GPU rendering ...
-    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL));
+    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         SkScalar intervals [] = { 10, 20 };
         SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25);
         paint.setPathEffect(pe)->unref();
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawRect(SkRect::MakeWH(10, 10), paint);
         }
     }
     picture.reset(recorder.endRecording());
     // ... but only when applied to drawPoint() calls
-    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
+    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
 
     // Nest the previous picture inside a new one.
     canvas = recorder.beginRecording(100, 100);
     {
         canvas->drawPicture(picture.get());
     }
     picture.reset(recorder.endRecording());
-    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
+    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
 }
 
 #endif
 
 static void test_savelayer_extraction(skiatest::Reporter* reporter) {
     static const int kWidth = 100;
     static const int kHeight = 100;
 
     // Create complex paint that the bounding box computation code can't
     // optimize away
     SkScalar blueToRedMatrix[20] = { 0 };
     blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1;
     SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix));
     SkAutoTUnref<SkImageFilter> filter(SkColorFilterImageFilter::Create(blueToRed.get()));
 
     SkPaint complexPaint;
     complexPaint.setImageFilter(filter);
 
     SkAutoTUnref<SkPicture> pict, child;
     SkRTreeFactory bbhFactory;
 
     {
         SkPictureRecorder recorder;
 
         SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight),
                                               &bbhFactory,
                                               SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
 
-        c->saveLayer(NULL, &complexPaint);
+        c->saveLayer(nullptr, &complexPaint);
         c->restore();
 
         child.reset(recorder.endRecording());
     }
 
     // create a picture with the structure:
     // 1)
     //      SaveLayer
     //      Restore
     // 2)
@@ skipping 14 matching lines @@
     //          DrawPicture with Matrix & Paint (with SaveLayer/Restore pair)
     //      Restore
     {
         SkPictureRecorder recorder;
 
         SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth),
                                               SkIntToScalar(kHeight),
                                               &bbhFactory,
                                               SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
         // 1)
-        c->saveLayer(NULL, &complexPaint); // layer #0
+        c->saveLayer(nullptr, &complexPaint); // layer #0
         c->restore();
 
         // 2)
-        c->saveLayer(NULL, NULL); // layer #1
+        c->saveLayer(nullptr, nullptr); // layer #1
             c->translate(kWidth / 2.0f, kHeight / 2.0f);
             SkRect r = SkRect::MakeXYWH(0, 0, kWidth/2, kHeight/2);
             c->saveLayer(&r, &complexPaint); // layer #2
             c->restore();
         c->restore();
 
         // 3)
         {
-            c->saveLayer(NULL, &complexPaint); // layer #3
+            c->saveLayer(nullptr, &complexPaint); // layer #3
             c->restore();
         }
 
         SkPaint layerPaint;
         layerPaint.setColor(SK_ColorRED);  // Non-alpha only to avoid SaveLayerDrawRestoreNooper
         // 4)
         {
-            c->saveLayer(NULL, &layerPaint);  // layer #4
+            c->saveLayer(nullptr, &layerPaint);  // layer #4
                 c->drawPicture(child);  // layer #5 inside picture
             c->restore();
         }
         // 5
         {
             SkPaint picturePaint;
             SkMatrix trans;
             trans.setTranslate(10, 10);
 
-            c->saveLayer(NULL, &layerPaint);  // layer #6
+            c->saveLayer(nullptr, &layerPaint);  // layer #6
                 c->drawPicture(child, &trans, &picturePaint); // layer #7 inside picture
             c->restore();
         }
 
         pict.reset(recorder.endRecording());
     }
 
     // Now test out the SaveLayer extraction
     if (!SkCanvas::Internal_Private_GetIgnoreSaveLayerBounds()) {
         const SkBigPicture* bp = pict->asSkBigPicture();
@@ skipping 13 matching lines @@
         const SkLayerInfo::BlockInfo& info3 = gpuData->block(3);
 
         // The parent/child layers appear in reverse order
         const SkLayerInfo::BlockInfo& info4 = gpuData->block(5);
         const SkLayerInfo::BlockInfo& info5 = gpuData->block(4);
 
         // The parent/child layers appear in reverse order
         const SkLayerInfo::BlockInfo& info6 = gpuData->block(7);
         const SkLayerInfo::BlockInfo& info7 = gpuData->block(6);
 
-        REPORTER_ASSERT(reporter, NULL == info0.fPicture);
+        REPORTER_ASSERT(reporter, nullptr == info0.fPicture);
         REPORTER_ASSERT(reporter, kWidth == info0.fBounds.width() &&
                                   kHeight == info0.fBounds.height());
         REPORTER_ASSERT(reporter, info0.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info0.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, 0 == info0.fBounds.fLeft && 0 == info0.fBounds.fTop);
-        REPORTER_ASSERT(reporter, NULL != info0.fPaint);
+        REPORTER_ASSERT(reporter, nullptr != info0.fPaint);
         REPORTER_ASSERT(reporter, !info0.fIsNested && !info0.fHasNestedLayers);
 
-        REPORTER_ASSERT(reporter, NULL == info1.fPicture);
+        REPORTER_ASSERT(reporter, nullptr == info1.fPicture);
         REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.width() &&
                                   kHeight/2.0 == info1.fBounds.height());
         REPORTER_ASSERT(reporter, info1.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info1.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.fLeft &&
                                   kHeight/2.0 == info1.fBounds.fTop);
-        REPORTER_ASSERT(reporter, NULL == info1.fPaint);
+        REPORTER_ASSERT(reporter, nullptr == info1.fPaint);
         REPORTER_ASSERT(reporter, !info1.fIsNested &&
                                   info1.fHasNestedLayers); // has a nested SL
 
-        REPORTER_ASSERT(reporter, NULL == info2.fPicture);
+        REPORTER_ASSERT(reporter, nullptr == info2.fPicture);
         REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.width() &&
                                   kHeight / 2 == info2.fBounds.height()); // bound reduces size
         REPORTER_ASSERT(reporter, !info2.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info2.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.fLeft &&   // translated
                                   kHeight / 2 == info2.fBounds.fTop);
-        REPORTER_ASSERT(reporter, NULL != info2.fPaint);
+        REPORTER_ASSERT(reporter, nullptr != info2.fPaint);
         REPORTER_ASSERT(reporter, info2.fIsNested && !info2.fHasNestedLayers); // is nested
 
-        REPORTER_ASSERT(reporter, NULL == info3.fPicture);
+        REPORTER_ASSERT(reporter, nullptr == info3.fPicture);
         REPORTER_ASSERT(reporter, kWidth == info3.fBounds.width() &&
                                   kHeight == info3.fBounds.height());
         REPORTER_ASSERT(reporter, info3.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info3.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, 0 == info3.fBounds.fLeft && 0 == info3.fBounds.fTop);
         REPORTER_ASSERT(reporter, info3.fPaint);
         REPORTER_ASSERT(reporter, !info3.fIsNested && !info3.fHasNestedLayers);
 
-        REPORTER_ASSERT(reporter, NULL == info4.fPicture);
+        REPORTER_ASSERT(reporter, nullptr == info4.fPicture);
         REPORTER_ASSERT(reporter, kWidth == info4.fBounds.width() &&
                                   kHeight == info4.fBounds.height());
         REPORTER_ASSERT(reporter, 0 == info4.fBounds.fLeft && 0 == info4.fBounds.fTop);
         REPORTER_ASSERT(reporter, info4.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info4.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, info4.fPaint);
         REPORTER_ASSERT(reporter, !info4.fIsNested &&
                                   info4.fHasNestedLayers); // has a nested SL
 
         REPORTER_ASSERT(reporter, child == info5.fPicture); // in a child picture
         REPORTER_ASSERT(reporter, kWidth == info5.fBounds.width() &&
                                   kHeight == info5.fBounds.height());
         REPORTER_ASSERT(reporter, 0 == info5.fBounds.fLeft && 0 == info5.fBounds.fTop);
         REPORTER_ASSERT(reporter, info5.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info5.fPreMat.isIdentity());
-        REPORTER_ASSERT(reporter, NULL != info5.fPaint);
+        REPORTER_ASSERT(reporter, nullptr != info5.fPaint);
         REPORTER_ASSERT(reporter, info5.fIsNested && !info5.fHasNestedLayers); // is nested
 
-        REPORTER_ASSERT(reporter, NULL == info6.fPicture);
+        REPORTER_ASSERT(reporter, nullptr == info6.fPicture);
         REPORTER_ASSERT(reporter, kWidth-10 == info6.fBounds.width() &&
                                   kHeight-10 == info6.fBounds.height());
         REPORTER_ASSERT(reporter, 10 == info6.fBounds.fLeft && 10 == info6.fBounds.fTop);
         REPORTER_ASSERT(reporter, info6.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info6.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, info6.fPaint);
         REPORTER_ASSERT(reporter, !info6.fIsNested &&
                                   info6.fHasNestedLayers); // has a nested SL
 
         REPORTER_ASSERT(reporter, child == info7.fPicture); // in a child picture
         REPORTER_ASSERT(reporter, kWidth == info7.fBounds.width() &&
                                   kHeight == info7.fBounds.height());
         REPORTER_ASSERT(reporter, 0 == info7.fBounds.fLeft && 0 == info7.fBounds.fTop);
         REPORTER_ASSERT(reporter, info7.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info7.fPreMat.isIdentity());
-        REPORTER_ASSERT(reporter, NULL != info7.fPaint);
+        REPORTER_ASSERT(reporter, nullptr != info7.fPaint);
         REPORTER_ASSERT(reporter, info7.fIsNested && !info7.fHasNestedLayers); // is nested
     }
 }
 
 static void test_has_text(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
 
     SkCanvas* canvas = recorder.beginRecording(100,100);
     {
         canvas->drawRect(SkRect::MakeWH(20, 20), SkPaint());
@@ skipping 33 matching lines @@
     }
     picture.reset(recorder.endRecording());
     REPORTER_ASSERT(reporter, picture->hasText());
 
     canvas = recorder.beginRecording(100,100);
     {
         SkPath path;
         path.moveTo(0, 0);
         path.lineTo(50, 50);
 
-        canvas->drawTextOnPath("Q", 1, path, NULL, SkPaint());
+        canvas->drawTextOnPath("Q", 1, path, nullptr, SkPaint());
     }
     picture.reset(recorder.endRecording());
     REPORTER_ASSERT(reporter, picture->hasText());
 
     // Nest the previous picture inside a new one.
     canvas = recorder.beginRecording(100,100);
     {
         canvas->drawPicture(picture.get());
     }
     picture.reset(recorder.endRecording());
@@ skipping 117 matching lines @@
 }
 
 // Test out SkPictureRecorder::partialReplay
 DEF_TEST(PictureRecorder_replay, reporter) {
     // check save/saveLayer state
     {
         SkPictureRecorder recorder;
 
         SkCanvas* canvas = recorder.beginRecording(10, 10);
 
-        canvas->saveLayer(NULL, NULL);
+        canvas->saveLayer(nullptr, nullptr);
 
         SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
 
         // The extra save and restore comes from the Copy process.
         check_save_state(reporter, copy, 2, 1, 3);
 
-        canvas->saveLayer(NULL, NULL);
+        canvas->saveLayer(nullptr, nullptr);
 
         SkAutoTUnref<SkPicture> final(recorder.endRecording());
 
         check_save_state(reporter, final, 1, 2, 3);
 
         // The copy shouldn't pick up any operations added after it was made
         check_save_state(reporter, copy, 2, 1, 3);
     }
 
     // (partially) check leakage of draw ops
@@ skipping 23 matching lines @@
         REPORTER_ASSERT(reporter, copy->uniqueID() != final->uniqueID());
 
         // The snapshot shouldn't pick up any operations added after it was made
         REPORTER_ASSERT(reporter, !copy->willPlayBackBitmaps());
     }
 
     // Recreate the Android partialReplay test case
     {
         SkPictureRecorder recorder;
 
-        SkCanvas* canvas = recorder.beginRecording(4, 3, NULL, 0);
+        SkCanvas* canvas = recorder.beginRecording(4, 3, nullptr, 0);
         create_imbalance(canvas);
 
         int expectedSaveCount = canvas->getSaveCount();
 
         SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
         check_balance(reporter, copy);
 
         REPORTER_ASSERT(reporter, expectedSaveCount = canvas->getSaveCount());
 
         // End the recording of source to test the picture finalization
@@ skipping 164 matching lines @@
     SkAutoDataUnref picture2(serialized_picture_from_bitmap(bm));
     REPORTER_ASSERT(reporter, picture1->equals(picture2));
     // Now test that a parse error was generated when trying to create a new SkPicture without
     // providing a function to decode the bitmap.
     ErrorContext context;
     context.fErrors = 0;
     context.fReporter = reporter;
     SkSetErrorCallback(assert_one_parse_error_cb, &context);
     SkMemoryStream pictureStream(picture1);
     SkClearLastError();
-    SkAutoTUnref<SkPicture> pictureFromStream(SkPicture::CreateFromStream(&pictureStream, NULL));
-    REPORTER_ASSERT(reporter, pictureFromStream.get() != NULL);
+    SkAutoTUnref<SkPicture> pictureFromStream(SkPicture::CreateFromStream(&pictureStream, nullptr));
+    REPORTER_ASSERT(reporter, pictureFromStream.get() != nullptr);
     SkClearLastError();
-    SkSetErrorCallback(NULL, NULL);
+    SkSetErrorCallback(nullptr, nullptr);
 }
 
 static void test_clip_bound_opt(skiatest::Reporter* reporter) {
     // Test for crbug.com/229011
     SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(4), SkIntToScalar(4),
                                     SkIntToScalar(2), SkIntToScalar(2));
     SkRect rect2 = SkRect::MakeXYWH(SkIntToScalar(7), SkIntToScalar(7),
                                     SkIntToScalar(1), SkIntToScalar(1));
     SkRect rect3 = SkRect::MakeXYWH(SkIntToScalar(6), SkIntToScalar(6),
                                     SkIntToScalar(1), SkIntToScalar(1));
@@ skipping 403 matching lines @@
             canvas->drawBitmap(mut, 0, 0);
             canvas->drawBitmap(immut, 800, 600);
         pic.reset(rec.endRecording());
     }
 
     // The picture shares the immutable pixels but copies the mutable ones.
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, !immut.pixelRef()->unique());
 
     // When the picture goes away, it's just our bitmaps holding the refs.
-    pic.reset(NULL);
+    pic.reset(nullptr);
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, immut.pixelRef()->unique());
 }
 
 // getRecordingCanvas() should return a SkCanvas when recording, null when not recording.
 DEF_TEST(Picture_getRecordingCanvas, r) {
     SkPictureRecorder rec;
     REPORTER_ASSERT(r, !rec.getRecordingCanvas());
     for (int i = 0; i < 3; i++) {
         rec.beginRecording(100, 100);
@@ skipping 25 matching lines @@
 
     SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
     SkAutoTUnref<SkPicture> deserializedPicture(SkPicture::CreateFromStream(rstream));
 
     REPORTER_ASSERT(r, SkToBool(deserializedPicture));
     REPORTER_ASSERT(r, deserializedPicture->cullRect().left() == 1);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().top() == 2);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().right() == 3);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().bottom() == 4);
 }