Style Change: NULL->nullptr

tests/CanvasStateTest.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 "CanvasStateHelpers.h"
 #include "SkCanvas.h"
 #include "SkCanvasStateUtils.h"
@@ skipping 19 matching lines @@
 
 // This class calls dlopen on the library passed in to the command line flag library, and handles
 // calling dlclose when it goes out of scope.
 class OpenLibResult {
 public:
     // If the flag library was passed to this run of the test, attempt to open it using dlopen and
     // report whether it succeeded.
     OpenLibResult(skiatest::Reporter* reporter) {
         if (FLAGS_library.count() == 1) {
             fHandle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
-            REPORTER_ASSERT_MESSAGE(reporter, fHandle != NULL, "Failed to open library!");
+            REPORTER_ASSERT_MESSAGE(reporter, fHandle != nullptr, "Failed to open library!");
         } else {
-            fHandle = NULL;
+            fHandle = nullptr;
         }
     }
 
     // Automatically call dlclose when going out of scope.
     ~OpenLibResult() {
         if (fHandle) {
             dlclose(fHandle);
         }
     }
 
@@ skipping 21 matching lines @@
     const SkCanvas::SaveFlags flags[] = { SkCanvas::kARGB_NoClipLayer_SaveFlag,
                                           SkCanvas::kARGB_ClipLayer_SaveFlag,
                                           SkCanvas::kARGB_NoClipLayer_SaveFlag
     };
     REPORTER_ASSERT(reporter, sizeof(layerAlpha) == sizeof(flags));
 
     bool (*drawFn)(SkCanvasState* state, float l, float t,
                    float r, float b, int32_t s);
 
     OpenLibResult openLibResult(reporter);
-    if (openLibResult.handle() != NULL) {
+    if (openLibResult.handle() != nullptr) {
         *(void**) (&drawFn) = dlsym(openLibResult.handle(),
                                     "complex_layers_draw_from_canvas_state");
     } else {
         drawFn = complex_layers_draw_from_canvas_state;
     }
 
     REPORTER_ASSERT(reporter, drawFn);
     if (!drawFn) {
         return;
     }
@@ skipping 81 matching lines @@
                                           SkCanvas::kARGB_ClipLayer_SaveFlag,
                                           SkCanvas::kARGB_NoClipLayer_SaveFlag,
     };
     REPORTER_ASSERT(reporter, sizeof(clipOps) == sizeof(flags));
 
     bool (*drawFn)(SkCanvasState* state, int32_t l, int32_t t,
                    int32_t r, int32_t b, int32_t clipOp,
                    int32_t regionRects, int32_t* rectCoords);
 
     OpenLibResult openLibResult(reporter);
-    if (openLibResult.handle() != NULL) {
+    if (openLibResult.handle() != nullptr) {
         *(void**) (&drawFn) = dlsym(openLibResult.handle(),
                                     "complex_clips_draw_from_canvas_state");
     } else {
         drawFn = complex_clips_draw_from_canvas_state;
     }
 
     REPORTER_ASSERT(reporter, drawFn);
     if (!drawFn) {
         return;
     }
@@ skipping 67 matching lines @@
     SkCanvas canvas(bitmap);
 
     canvas.setDrawFilter(&drawFilter);
 
     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
     REPORTER_ASSERT(reporter, state);
     SkCanvas* tmpCanvas = SkCanvasStateUtils::CreateFromCanvasState(state);
     REPORTER_ASSERT(reporter, tmpCanvas);
 
     REPORTER_ASSERT(reporter, canvas.getDrawFilter());
-    REPORTER_ASSERT(reporter, NULL == tmpCanvas->getDrawFilter());
+    REPORTER_ASSERT(reporter, nullptr == tmpCanvas->getDrawFilter());
 
     tmpCanvas->unref();
     SkCanvasStateUtils::ReleaseCanvasState(state);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // we need this function to prevent SkError from printing to stdout
 static void error_callback(SkError code, void* ctx) {}
 
 DEF_TEST(CanvasState_test_soft_clips, reporter) {
     SkBitmap bitmap;
     bitmap.allocN32Pixels(10, 10);
     SkCanvas canvas(bitmap);
 
     SkRRect roundRect;
     roundRect.setOval(SkRect::MakeWH(5, 5));
 
     canvas.clipRRect(roundRect, SkRegion::kIntersect_Op, true);
 
-    SkSetErrorCallback(error_callback, NULL);
+    SkSetErrorCallback(error_callback, nullptr);
 
     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
     REPORTER_ASSERT(reporter, !state);
 
     REPORTER_ASSERT(reporter, kInvalidOperation_SkError == SkGetLastError());
     SkClearLastError();
 }
 
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
 #include "SkClipStack.h"
 DEF_TEST(CanvasState_test_saveLayer_clip, reporter) {
     const int WIDTH = 100;
     const int HEIGHT = 100;
     const int LAYER_WIDTH = 50;
     const int LAYER_HEIGHT = 50;
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(WIDTH, HEIGHT);
     SkCanvas canvas(bitmap);
 
     SkRect bounds = SkRect::MakeWH(SkIntToScalar(LAYER_WIDTH), SkIntToScalar(LAYER_HEIGHT));
     canvas.clipRect(SkRect::MakeWH(SkIntToScalar(WIDTH), SkIntToScalar(HEIGHT)));
 
     // Check that saveLayer without the kClipToLayer_SaveFlag leaves the
     // clip stack unchanged.
-    canvas.saveLayer(&bounds, NULL, SkCanvas::kARGB_NoClipLayer_SaveFlag);
+    canvas.saveLayer(&bounds, nullptr, SkCanvas::kARGB_NoClipLayer_SaveFlag);
     SkRect clipStackBounds;
     SkClipStack::BoundsType boundsType;
     canvas.getClipStack()->getBounds(&clipStackBounds, &boundsType);
     REPORTER_ASSERT(reporter, clipStackBounds.width() == WIDTH);
     REPORTER_ASSERT(reporter, clipStackBounds.height() == HEIGHT);
     canvas.restore();
 
     // Check that saveLayer with the kClipToLayer_SaveFlag sets the clip
     // stack to the layer bounds.
-    canvas.saveLayer(&bounds, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
+    canvas.saveLayer(&bounds, nullptr, SkCanvas::kARGB_ClipLayer_SaveFlag);
     canvas.getClipStack()->getBounds(&clipStackBounds, &boundsType);
     REPORTER_ASSERT(reporter, clipStackBounds.width() == LAYER_WIDTH);
     REPORTER_ASSERT(reporter, clipStackBounds.height() == LAYER_HEIGHT);
 
     canvas.restore();
 }
 #endif