Style Change: NULL->nullptr

gm/gradients.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkGradientShader.h"
 
@@ skipping 13 matching lines @@
 static const SkScalar gPos2[] = {
     0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
 };
 
 static const SkScalar gPosClamp[]   = {0.0f, 0.0f, 1.0f, 1.0f};
 static const SkColor  gColorClamp[] = {
     SK_ColorRED, SK_ColorGREEN, SK_ColorGREEN, SK_ColorBLUE
 };
 
 static const GradData gGradData[] = {
-    { 2, gColors, NULL },
+    { 2, gColors, nullptr },
     { 2, gColors, gPos0 },
     { 2, gColors, gPos1 },
-    { 5, gColors, NULL },
+    { 5, gColors, nullptr },
     { 5, gColors, gPos2 },
     { 4, gColorClamp, gPosClamp }
 };
 
 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
     return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
                                           data.fCount, tm, 0, &localMatrix);
 }
 
@@ skipping 256 matching lines @@
 
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(300) };
         SkPaint paint;
         paint.setAntiAlias(true);
 
         SkPoint center;
         center.iset(0, 300);
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
         SkShader* shader = SkGradientShader::CreateRadial(
             SkPoint(center),
-            SkIntToScalar(200), gColors, NULL, 5,
+            SkIntToScalar(200), gColors, nullptr, 5,
             SkShader::kClamp_TileMode);
         paint.setShader(shader);
         canvas->drawRect(r, paint);
         shader->unref();
     }
 
 private:
     typedef GM INHERITED;
 };
 DEF_GM( return new ClampedGradientsGM; )
@@ skipping 69 matching lines @@
         SkPoint center;
         center.set(cx, cy);
 
         // We can either interpolate endpoints and premultiply each point (default, more precision),
         // or premultiply the endpoints first, avoiding the need to premultiply each point (cheap).
         const uint32_t flags[] = { 0, SkGradientShader::kInterpolateColorsInPremul_Flag };
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(flags); i++) {
             SkAutoTUnref<SkShader> sweep(
                     SkGradientShader::CreateSweep(cx, cy, sweep_colors,
-                                                  NULL, SK_ARRAY_COUNT(sweep_colors),
-                                                  flags[i], NULL));
+                                                  nullptr, SK_ARRAY_COUNT(sweep_colors),
+                                                  flags[i], nullptr));
             SkAutoTUnref<SkShader> radial1(
                     SkGradientShader::CreateRadial(center, radius, colors1,
-                                                   NULL, SK_ARRAY_COUNT(colors1),
+                                                   nullptr, SK_ARRAY_COUNT(colors1),
                                                    SkShader::kClamp_TileMode,
-                                                   flags[i], NULL));
+                                                   flags[i], nullptr));
             SkAutoTUnref<SkShader> radial2(
                     SkGradientShader::CreateRadial(center, radius, colors2,
-                                                   NULL, SK_ARRAY_COUNT(colors2),
+                                                   nullptr, SK_ARRAY_COUNT(colors2),
                                                    SkShader::kClamp_TileMode,
-                                                   flags[i], NULL));
+                                                   flags[i], nullptr));
             paint1.setShader(sweep);
             paint2.setShader(radial1);
             paint3.setShader(radial2);
 
             canvas->drawCircle(cx, cy, radius, paint1);
             canvas->drawCircle(cx, cy, radius, paint3);
             canvas->drawCircle(cx, cy, radius, paint2);
 
             canvas->translate(400, 0);
         }
@@ skipping 12 matching lines @@
     SkString onShortName() override { return SkString("radial_gradient3"); }
 
     SkISize onISize() override { return SkISize::Make(500, 500); }
 
     bool runAsBench() const override { return true; }
 
     void onOnceBeforeDraw() override {
         const SkPoint center = { 0, 0 };
         const SkScalar kRadius = 3000;
         const SkColor gColors[] = { 0xFFFFFFFF, 0xFF000000 };
-        fShader.reset(SkGradientShader::CreateRadial(center, kRadius, gColors, NULL, 2,
+        fShader.reset(SkGradientShader::CreateRadial(center, kRadius, gColors, nullptr, 2,
                                                      SkShader::kClamp_TileMode));
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setShader(fShader);
         canvas->drawRect(SkRect::MakeWH(500, 500), paint);
     }
     
 private:
@@ skipping 68 matching lines @@
                     (index + 1) * kHeight), paint);
         }
     }
     
 private:
     typedef GM INHERITED;
 };
 DEF_GM( return new LinearGradientGM; )
 
 }