Style Change: NULL->nullptr

bench/PatchGridBench.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 "Benchmark.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
@@ skipping 78 matching lines @@
             {{50,125},{150,125},{250,125},{350,125},{450,125}},
             {{50,175},{150,175},{220,225},{350,175},{470,225}},
             {{50,225},{150,225},{220,175},{350,225},{470,155}},
             {{50,275},{150,275},{250,275},{350,275},{400,305}},
             {{50,325},{150,325},{250,325},{350,325},{450,325}}
         };
         
         static const int kRows = 3;
         static const int kCols = 4;
         
-        fGrid.reset(kRows, kCols, SkPatchGrid::kColors_VertexType, NULL);
+        fGrid.reset(kRows, kCols, SkPatchGrid::kColors_VertexType, nullptr);
         for (int i = 0; i < kRows; i++) {
             for (int j = 0; j < kCols; j++) {
                 SkPoint points[12];
                 
                 //set corners
                 points[SkPatchUtils::kTopP0_CubicCtrlPts] = vertices[i][j];
                 points[SkPatchUtils::kTopP3_CubicCtrlPts] = vertices[i][j + 1];
                 points[SkPatchUtils::kBottomP0_CubicCtrlPts] = vertices[i + 1][j];
                 points[SkPatchUtils::kBottomP3_CubicCtrlPts] = vertices[i + 1][j + 1];
                 
@@ skipping 14 matching lines @@
                 colors[2] = cornerColors[i + 1][j + 1];
                 
                 SkPoint texs[4];
                 texs[0] = texCoords[i][j];
                 texs[1] = texCoords[i][j + 1];
                 texs[3] = texCoords[i + 1][j];
                 texs[2] = texCoords[i + 1][j + 1];
                 
                 switch (fVertexMode) {
                     case kNone_VertexMode:
-                        fGrid.setPatch(j, i, points, NULL, NULL);
+                        fGrid.setPatch(j, i, points, nullptr, nullptr);
                         break;
                     case kColors_VertexMode:
-                        fGrid.setPatch(j, i, points, colors, NULL);
+                        fGrid.setPatch(j, i, points, colors, nullptr);
                         break;
                     case kTexCoords_VertexMode:
-                        fGrid.setPatch(j, i, points, NULL, texs);
+                        fGrid.setPatch(j, i, points, nullptr, texs);
                         break;
                     case kBoth_VertexMode:
                         fGrid.setPatch(j, i, points, colors, texs);
                         break;
                     default:
                         break;
                 }
             }
         }
     }
     
     // override this method to change the shader
     SkShader* createShader() {
         const SkColor colors[] = {
             SK_ColorRED, SK_ColorCYAN, SK_ColorGREEN, SK_ColorWHITE,
             SK_ColorMAGENTA, SK_ColorBLUE, SK_ColorYELLOW,
         };
         const SkPoint pts[] = { { 200.f / 4.f, 0.f }, { 3.f * 200.f / 4, 200.f } };
         
-        return SkGradientShader::CreateLinear(pts, colors, NULL,
+        return SkGradientShader::CreateLinear(pts, colors, nullptr,
                                               SK_ARRAY_COUNT(colors),
                                               SkShader::kMirror_TileMode);
     }
 
 protected:
     const char* onGetName() override {
         SkString vertexMode;
         switch (fVertexMode) {
             case kNone_VertexMode:
                 vertexMode.set("meshlines");
@@ skipping 30 matching lines @@
     }
     
     void onPreDraw() override {
         this->setGrid();
         switch (fVertexMode) {
             case kTexCoords_VertexMode:
             case kBoth_VertexMode:
                 fPaint.setShader(createShader())->unref();
                 break;
             default:
-                fPaint.setShader(NULL);
+                fPaint.setShader(nullptr);
                 break;
         }
         this->setupPaint(&fPaint);
     }
 
     void onDraw(const int loops, SkCanvas* canvas) override {
         this->setScale(canvas);
         for (int i = 0; i < loops; i++) {
             fGrid.draw(canvas, fPaint);
         }
@@ skipping 28 matching lines @@
 DEF_BENCH( return new PatchGridBench(PatchGridBench::kMedium_Size,
                                      PatchGridBench::kBoth_VertexMode); )
 DEF_BENCH( return new PatchGridBench(PatchGridBench::kBig_Size,
                                      PatchGridBench::kNone_VertexMode); )
 DEF_BENCH( return new PatchGridBench(PatchGridBench::kBig_Size,
                                      PatchGridBench::kColors_VertexMode); )
 DEF_BENCH( return new PatchGridBench(PatchGridBench::kBig_Size,
                                      PatchGridBench::kTexCoords_VertexMode); )
 DEF_BENCH( return new PatchGridBench(PatchGridBench::kBig_Size,
                                      PatchGridBench::kBoth_VertexMode); )