Style Change: NULL->nullptr

src/utils/android/SkAndroidSDKCanvas.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAndroidSDKCanvas.h"
 
 #include "SkColorFilter.h"
 #include "SkPaint.h"
 #include "SkPathEffect.h"
 #include "SkShader.h"
 #include "SkTLazy.h"
 
 namespace {
 
 /** Discard SkShaders not exposed by the Android Java API. */
 
 void CheckShader(SkPaint* paint) {
     SkShader* shader = paint->getShader();
     if (!shader) {
         return;
     }
 
     if (shader->isABitmap()) {
         return;
     }
-    if (shader->asACompose(NULL)) {
+    if (shader->asACompose(nullptr)) {
         return;
     }
-    SkShader::GradientType gtype = shader->asAGradient(NULL);
+    SkShader::GradientType gtype = shader->asAGradient(nullptr);
     if (gtype == SkShader::kLinear_GradientType ||
         gtype == SkShader::kRadial_GradientType ||
         gtype == SkShader::kSweep_GradientType) {
         return;
     }
-    paint->setShader(NULL);
+    paint->setShader(nullptr);
 }
 
 void Filter(SkPaint* paint) {
 
     uint32_t flags = paint->getFlags();
     flags &= ~SkPaint::kLCDRenderText_Flag;
     paint->setFlags(flags);
 
     // Android doesn't support Xfermodes above kLighten_Mode
     SkXfermode::Mode mode;
     SkXfermode::AsMode(paint->getXfermode(), &mode);
     if (mode > SkXfermode::kLighten_Mode) {
-        paint->setXfermode(NULL);
+        paint->setXfermode(nullptr);
     }
 
     // Force bilinear scaling or none
     if (paint->getFilterQuality() != kNone_SkFilterQuality) {
         paint->setFilterQuality(kLow_SkFilterQuality);
     }
 
     CheckShader(paint);
 
     // Android SDK only supports mode & matrix color filters
     // (and, again, no modes above kLighten_Mode).
     SkColorFilter* cf = paint->getColorFilter();
     if (cf) {
         SkColor color;
         SkXfermode::Mode mode;
         SkScalar srcColorMatrix[20];
         bool isMode = cf->asColorMode(&color, &mode);
         if (isMode && mode > SkXfermode::kLighten_Mode) {
             paint->setColorFilter(
                 SkColorFilter::CreateModeFilter(color, SkXfermode::kSrcOver_Mode));
         } else if (!isMode && !cf->asColorMatrix(srcColorMatrix)) {
-            paint->setColorFilter(NULL);
+            paint->setColorFilter(nullptr);
         }
     }
 
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     SkPathEffect* pe = paint->getPathEffect();
     if (pe && !pe->exposedInAndroidJavaAPI()) {
-        paint->setPathEffect(NULL);
+        paint->setPathEffect(nullptr);
     }
 #endif
 
     // TODO: Android doesn't support all the flags that can be passed to
     // blur filters; we need plumbing to get them out.
 
-    paint->setImageFilter(NULL);
-    paint->setLooper(NULL);
+    paint->setImageFilter(nullptr);
+    paint->setLooper(nullptr);
 };
 
 }  // namespace
 
 #define FILTER(p)             \
     SkPaint filteredPaint(p); \
     Filter(&filteredPaint);
 
 #define FILTER_PTR(p)                          \
     SkTLazy<SkPaint> lazyPaint;                \
     SkPaint* filteredPaint = (SkPaint*) p;     \
     if (p) {                                   \
         filteredPaint = lazyPaint.set(*p);     \
         Filter(filteredPaint);                 \
     }
 
 
-SkAndroidSDKCanvas::SkAndroidSDKCanvas() : fProxyTarget(NULL) { }
+SkAndroidSDKCanvas::SkAndroidSDKCanvas() : fProxyTarget(nullptr) { }
 
 void SkAndroidSDKCanvas::reset(SkCanvas* newTarget) { fProxyTarget = newTarget; }
 
 void SkAndroidSDKCanvas::onDrawPaint(const SkPaint& paint) {
     FILTER(paint);
     fProxyTarget->drawPaint(filteredPaint);
 }
 void SkAndroidSDKCanvas::onDrawPoints(PointMode pMode,
                                                size_t count,
                                                const SkPoint pts[],
@@ skipping 168 matching lines @@
         pmap->reset(info, addr, rowBytes);
         return true;
     }
     return false;
 }
 
 bool SkAndroidSDKCanvas::onAccessTopLayerPixels(SkPixmap* pmap) {
     SkASSERT(pmap);
     SkImageInfo info;
     size_t rowBytes; 
-    const void* addr = fProxyTarget->accessTopLayerPixels(&info, &rowBytes, NULL);
+    const void* addr = fProxyTarget->accessTopLayerPixels(&info, &rowBytes, nullptr);
     if (addr) {
         pmap->reset(info, addr, rowBytes);
         return true;
     }
     return false;
 }
 
 void SkAndroidSDKCanvas::willSave() {
     fProxyTarget->save();
 }
@@ skipping 37 matching lines @@
     fProxyTarget->clipPath(path, op, style);
 }
 
 void SkAndroidSDKCanvas::onClipRegion(const SkRegion& region, SkRegion::Op op) {
     fProxyTarget->clipRegion(region, op);
 }
 
 void SkAndroidSDKCanvas::onDiscard() { fProxyTarget->discard(); }