Style Change: NULL->nullptr

src/effects/SkEmbossMaskFilter.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkEmbossMaskFilter.h"
 #include "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
@@ skipping 17 matching lines @@
 
 SkMaskFilter* SkBlurMaskFilter::CreateEmboss(const SkScalar direction[3],
                                              SkScalar ambient, SkScalar specular,
                                              SkScalar blurRadius) {
     return SkBlurMaskFilter::CreateEmboss(SkBlurMask::ConvertRadiusToSigma(blurRadius),
                                           direction, ambient, specular);
 }
 
 SkMaskFilter* SkBlurMaskFilter::CreateEmboss(SkScalar blurSigma, const SkScalar direction[3],
                                              SkScalar ambient, SkScalar specular) {
-    if (direction == NULL) {
-        return NULL;
+    if (direction == nullptr) {
+        return nullptr;
     }
 
     // ambient should be 0...1 as a scalar
     int am = pin2byte(SkScalarToFixed(ambient) >> 8);
 
     // specular should be 0..15.99 as a scalar
     int sp = pin2byte(SkScalarToFixed(specular) >> 12);
 
     SkEmbossMaskFilter::Light   light;
 
@@ skipping 30 matching lines @@
 
     if (!SkBlurMask::BoxBlur(dst, src, sigma, kInner_SkBlurStyle, kLow_SkBlurQuality)) {
         return false;
     }
 
     dst->fFormat = SkMask::k3D_Format;
     if (margin) {
         margin->set(SkScalarCeilToInt(3*sigma), SkScalarCeilToInt(3*sigma));
     }
 
-    if (src.fImage == NULL) {
+    if (src.fImage == nullptr) {
         return true;
     }
 
     // create a larger buffer for the other two channels (should force fBlur to do this for us)
 
     {
         uint8_t* alphaPlane = dst->fImage;
         size_t   planeSize = dst->computeImageSize();
         if (0 == planeSize) {
             return false;   // too big to allocate, abort
@@ skipping 23 matching lines @@
     return true;
 }
 
 SkFlattenable* SkEmbossMaskFilter::CreateProc(SkReadBuffer& buffer) {
     Light light;
     if (buffer.readByteArray(&light, sizeof(Light))) {
         light.fPad = 0; // for the font-cache lookup to be clean
         const SkScalar sigma = buffer.readScalar();
         return Create(sigma, light);
     }
-    return NULL;
+    return nullptr;
 }
 
 void SkEmbossMaskFilter::flatten(SkWriteBuffer& buffer) const {
     Light tmpLight = fLight;
     tmpLight.fPad = 0;    // for the font-cache lookup to be clean
     buffer.writeByteArray(&tmpLight, sizeof(tmpLight));
     buffer.writeScalar(fBlurSigma);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkEmbossMaskFilter::toString(SkString* str) const {
     str->append("SkEmbossMaskFilter: (");
 
     str->append("direction: (");
     str->appendScalar(fLight.fDirection[0]);
     str->append(", ");
     str->appendScalar(fLight.fDirection[1]);
     str->append(", ");
     str->appendScalar(fLight.fDirection[2]);
     str->append(") ");
 
     str->appendf("ambient: %d specular: %d ",
         fLight.fAmbient, fLight.fSpecular);
 
     str->append("blurSigma: ");
     str->appendScalar(fBlurSigma);
     str->append(")");
 }
 #endif