Style Change: NULL->nullptr

tests/LayerRasterizerTest.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDeque.h"
 #include "SkLayerRasterizer.h"
 #include "SkPaint.h"
@@ skipping 63 matching lines @@
     SkPaint     fPaint;
     SkVector    fOffset;
 };
 
 static bool equals(const SkLayerRasterizer_Rec& rec1, const SkLayerRasterizer_Rec& rec2) {
     return rec1.fPaint == rec2.fPaint && rec1.fOffset == rec2.fOffset;
 }
 
 DEF_TEST(LayerRasterizer_copy, reporter) {
     SkLayerRasterizer::Builder builder;
-    REPORTER_ASSERT(reporter, NULL == builder.snapshotRasterizer());
+    REPORTER_ASSERT(reporter, nullptr == builder.snapshotRasterizer());
     SkPaint paint;
     // Create a bunch of paints with different flags.
     for (uint32_t flags = 0x01; flags < SkPaint::kAllFlags; flags <<= 1) {
         paint.setFlags(flags);
         builder.addLayer(paint, static_cast<SkScalar>(flags), static_cast<SkScalar>(flags));
     }
 
     // Create a layer rasterizer with all the existing layers.
     SkAutoTUnref<SkLayerRasterizer> firstCopy(builder.snapshotRasterizer());
 
     // Add one more layer.
     paint.setFlags(SkPaint::kAllFlags);
     builder.addLayer(paint);
 
     SkAutoTUnref<SkLayerRasterizer> oneLarger(builder.snapshotRasterizer());
     SkAutoTUnref<SkLayerRasterizer> detached(builder.detachRasterizer());
 
     // Check the counts for consistency.
     const int largerCount = LayerRasterizerTester::CountLayers(*oneLarger.get());
     const int smallerCount = LayerRasterizerTester::CountLayers(*firstCopy.get());
     REPORTER_ASSERT(reporter, largerCount == LayerRasterizerTester::CountLayers(*detached.get()));
     REPORTER_ASSERT(reporter, smallerCount == largerCount - 1);
 
-    const SkLayerRasterizer_Rec* recFirstCopy = NULL;
-    const SkLayerRasterizer_Rec* recOneLarger = NULL;
-    const SkLayerRasterizer_Rec* recDetached = NULL;
+    const SkLayerRasterizer_Rec* recFirstCopy = nullptr;
+    const SkLayerRasterizer_Rec* recOneLarger = nullptr;
+    const SkLayerRasterizer_Rec* recDetached = nullptr;
 
     const SkDeque& layersFirstCopy = LayerRasterizerTester::GetLayers(*firstCopy.get());
     const SkDeque& layersOneLarger = LayerRasterizerTester::GetLayers(*oneLarger.get());
     const SkDeque& layersDetached = LayerRasterizerTester::GetLayers(*detached.get());
 
     // Ensure that our version of SkLayerRasterizer_Rec is the same as the one in
     // SkLayerRasterizer.cpp - or at least the same size. If the order were switched, we
     // would fail the test elsewhere.
     REPORTER_ASSERT(reporter, layersFirstCopy.elemSize() == sizeof(SkLayerRasterizer_Rec));
     REPORTER_ASSERT(reporter, layersOneLarger.elemSize() == sizeof(SkLayerRasterizer_Rec));
     REPORTER_ASSERT(reporter, layersDetached.elemSize() == sizeof(SkLayerRasterizer_Rec));
 
     SkDeque::F2BIter iterFirstCopy(layersFirstCopy);
     SkDeque::F2BIter iterOneLarger(layersOneLarger);
     SkDeque::F2BIter iterDetached(layersDetached);
 
     for (int i = 0; i < largerCount; ++i) {
         recFirstCopy = static_cast<const SkLayerRasterizer_Rec*>(iterFirstCopy.next());
         recOneLarger = static_cast<const SkLayerRasterizer_Rec*>(iterOneLarger.next());
         recDetached  = static_cast<const SkLayerRasterizer_Rec*>(iterDetached.next());
 
         REPORTER_ASSERT(reporter, equals(*recOneLarger, *recDetached));
         if (smallerCount == i) {
-            REPORTER_ASSERT(reporter, recFirstCopy == NULL);
+            REPORTER_ASSERT(reporter, recFirstCopy == nullptr);
         } else {
             REPORTER_ASSERT(reporter, equals(*recFirstCopy, *recOneLarger));
         }
     }
 }
 
 DEF_TEST(LayerRasterizer_detachEmpty, reporter) {
     SkLayerRasterizer::Builder builder;
-    REPORTER_ASSERT(reporter, NULL == builder.detachRasterizer());
+    REPORTER_ASSERT(reporter, nullptr == builder.detachRasterizer());
 }