Style Change: NULL->nullptr

src/effects/SkBlurMaskFilter.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 "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
@@ skipping 107 matching lines @@
 
     friend class SkBlurMaskFilter;
 
     typedef SkMaskFilter INHERITED;
 };
 
 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
 
 SkMaskFilter* SkBlurMaskFilter::Create(SkBlurStyle style, SkScalar sigma, uint32_t flags) {
     if (!SkScalarIsFinite(sigma) || sigma <= 0) {
-        return NULL;
+        return nullptr;
     }
     if ((unsigned)style > (unsigned)kLastEnum_SkBlurStyle) {
-        return NULL;
+        return nullptr;
     }
     if (flags > SkBlurMaskFilter::kAll_BlurFlag) {
-        return NULL;
+        return nullptr;
     }
     return new SkBlurMaskFilterImpl(sigma, style, flags);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle style, uint32_t flags)
     : fSigma(sigma)
     , fBlurStyle(style)
     , fBlurFlags(flags) {
@@ skipping 40 matching lines @@
                                           SkIPoint* margin, SkMask::CreateMode createMode) const{
     SkScalar sigma = computeXformedSigma(matrix);
 
     return SkBlurMask::BlurRRect(sigma, dst, r, fBlurStyle,
                                 margin, createMode);
 }
 
 #include "SkCanvas.h"
 
 static bool prepare_to_draw_into_mask(const SkRect& bounds, SkMask* mask) {
-    SkASSERT(mask != NULL);
+    SkASSERT(mask != nullptr);
 
     mask->fBounds = bounds.roundOut();
     mask->fRowBytes = SkAlign4(mask->fBounds.width());
     mask->fFormat = SkMask::kA8_Format;
     const size_t size = mask->computeImageSize();
     mask->fImage = SkMask::AllocImage(size);
-    if (NULL == mask->fImage) {
+    if (nullptr == mask->fImage) {
         return false;
     }
 
     // FIXME: use sk_calloc in AllocImage?
     sk_bzero(mask->fImage, size);
     return true;
 }
 
 static bool draw_rrect_into_mask(const SkRRect rrect, SkMask* mask) {
     if (!prepare_to_draw_into_mask(rrect.rect(), mask)) {
@@ skipping 96 matching lines @@
 #ifdef SK_IGNORE_FAST_RRECT_BLUR
 SK_CONF_DECLARE( bool, c_analyticBlurRRect, "mask.filter.blur.analyticblurrrect", false, "Use the faster analytic blur approach for ninepatch rects" );
 #else
 SK_CONF_DECLARE( bool, c_analyticBlurRRect, "mask.filter.blur.analyticblurrrect", true, "Use the faster analytic blur approach for ninepatch round rects" );
 #endif
 
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
                                         NinePatch* patch) const {
-    SkASSERT(patch != NULL);
+    SkASSERT(patch != nullptr);
     switch (rrect.getType()) {
         case SkRRect::kEmpty_Type:
             // Nothing to draw.
             return kFalse_FilterReturn;
 
         case SkRRect::kRect_Type:
             // We should have caught this earlier.
             SkASSERT(false);
             // Fall through.
         case SkRRect::kOval_Type:
@@ skipping 16 matching lines @@
 
     // TODO: take clipBounds into account to limit our coordinates up front
     // for now, just skip too-large src rects (to take the old code path).
     if (rect_exceeds(rrect.rect(), SkIntToScalar(32767))) {
         return kUnimplemented_FilterReturn;
     }
 
     SkIPoint margin;
     SkMask  srcM, dstM;
     srcM.fBounds = rrect.rect().roundOut();
-    srcM.fImage = NULL;
+    srcM.fImage = nullptr;
     srcM.fFormat = SkMask::kA8_Format;
     srcM.fRowBytes = 0;
 
     bool filterResult = false;
     if (c_analyticBlurRRect) {
         // special case for fast round rect blur
         // don't actually do the blur the first time, just compute the correct size
         filterResult = this->filterRRectMask(&dstM, rrect, matrix, &margin,
                                             SkMask::kJustComputeBounds_CreateMode);
     }
@@ skipping 68 matching lines @@
                 return kFalse_FilterReturn;
             }
         }
         cache = add_cached_rrect(&patch->fMask, sigma, fBlurStyle, this->getQuality(), smallRR);
     }
 
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
     patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
-    SkASSERT(NULL == patch->fCache);
+    SkASSERT(nullptr == patch->fCache);
     patch->fCache = cache;  // transfer ownership to patch
     return kTrue_FilterReturn;
 }
 
 SK_CONF_DECLARE( bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", true, "Use the faster analytic blur approach for ninepatch rects" );
 
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
                                         const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
@@ skipping 10 matching lines @@
 
     // TODO: take clipBounds into account to limit our coordinates up front
     // for now, just skip too-large src rects (to take the old code path).
     if (rect_exceeds(rects[0], SkIntToScalar(32767))) {
         return kUnimplemented_FilterReturn;
     }
 
     SkIPoint margin;
     SkMask  srcM, dstM;
     srcM.fBounds = rects[0].roundOut();
-    srcM.fImage = NULL;
+    srcM.fImage = nullptr;
     srcM.fFormat = SkMask::kA8_Format;
     srcM.fRowBytes = 0;
 
     bool filterResult = false;
     if (count == 1 && c_analyticBlurNinepatch) {
         // special case for fast rect blur
         // don't actually do the blur the first time, just compute the correct size
         filterResult = this->filterRectMask(&dstM, rects[0], matrix, &margin,
                                             SkMask::kJustComputeBounds_CreateMode);
     } else {
@@ skipping 78 matching lines @@
             if (!this->filterRectMask(&patch->fMask, smallR[0], matrix, &margin,
                                       SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
                 return kFalse_FilterReturn;
             }
         }
         cache = add_cached_rects(&patch->fMask, sigma, fBlurStyle, this->getQuality(), smallR, count);
     }
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter = center;
-    SkASSERT(NULL == patch->fCache);
+    SkASSERT(nullptr == patch->fCache);
     patch->fCache = cache;  // transfer ownership to patch
     return kTrue_FilterReturn;
 }
 
 void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
                                              SkRect* dst) const {
     SkScalar pad = 3.0f * fSigma;
 
     dst->set(src.fLeft  - pad, src.fTop    - pad,
              src.fRight + pad, src.fBottom + pad);
 }
 
 SkFlattenable* SkBlurMaskFilterImpl::CreateProc(SkReadBuffer& buffer) {
     const SkScalar sigma = buffer.readScalar();
     const unsigned style = buffer.readUInt();
     const unsigned flags = buffer.readUInt();
     if (style <= kLastEnum_SkBlurStyle) {
         return SkBlurMaskFilter::Create((SkBlurStyle)style, sigma, flags);
     }
-    return NULL;
+    return nullptr;
 }
 
 void SkBlurMaskFilterImpl::flatten(SkWriteBuffer& buffer) const {
     buffer.writeScalar(fSigma);
     buffer.writeUInt(fBlurStyle);
     buffer.writeUInt(fBlurFlags);
 }
 
 #if SK_SUPPORT_GPU
 
 class GrGLRectBlurEffect;
 
 class GrRectBlurEffect : public GrFragmentProcessor {
 public:
     virtual ~GrRectBlurEffect();
 
     const char* name() const override { return "RectBlur"; }
 
     /**
      * Create a simple filter effect with custom bicubic coefficients.
      */
     static GrFragmentProcessor* Create(GrTextureProvider *textureProvider, const SkRect& rect,
                                        float sigma) {
-        GrTexture *blurProfileTexture = NULL;
+        GrTexture *blurProfileTexture = nullptr;
         int doubleProfileSize = SkScalarCeilToInt(12*sigma);
 
         if (doubleProfileSize >= rect.width() || doubleProfileSize >= rect.height()) {
             // if the blur sigma is too large so the gaussian overlaps the whole
             // rect in either direction, fall back to CPU path for now.
 
-            return NULL;
+            return nullptr;
         }
 
         bool createdBlurProfileTexture = CreateBlurProfileTexture(
             textureProvider, sigma, &blurProfileTexture);
         SkAutoTUnref<GrTexture> hunref(blurProfileTexture);
         if (!createdBlurProfileTexture) {
-           return NULL;
+           return nullptr;
         }
         return new GrRectBlurEffect(rect, sigma, blurProfileTexture);
     }
 
     const SkRect& getRect() const { return fRect; }
     float getSigma() const { return fSigma; }
 
 private:
     GrGLFragmentProcessor* onCreateGLInstance() const override;
 
@@ skipping 111 matching lines @@
     texDesc.fWidth = profileSize;
     texDesc.fHeight = 1;
     texDesc.fConfig = kAlpha_8_GrPixelConfig;
 
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey key;
     GrUniqueKey::Builder builder(&key, kDomain, 1);
     builder[0] = profileSize;
     builder.finish();
 
-    uint8_t *profile = NULL;
-    SkAutoTDeleteArray<uint8_t> ada(NULL);
+    uint8_t *profile = nullptr;
+    SkAutoTDeleteArray<uint8_t> ada(nullptr);
 
     *blurProfileTexture = textureProvider->findAndRefTextureByUniqueKey(key);
 
-    if (NULL == *blurProfileTexture) {
+    if (nullptr == *blurProfileTexture) {
 
         SkBlurMask::ComputeBlurProfile(sigma, &profile);
         ada.reset(profile);
 
         *blurProfileTexture = textureProvider->createTexture(texDesc, true, profile, 0);
 
-        if (NULL == *blurProfileTexture) {
+        if (nullptr == *blurProfileTexture) {
             return false;
         }
         textureProvider->assignUniqueKeyToTexture(key, *blurProfileTexture);
     }
 
     return true;
 }
 
 GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma,
                                    GrTexture *blur_profile)
@@ skipping 111 matching lines @@
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 
 GrFragmentProcessor* GrRRectBlurEffect::Create(GrTextureProvider* texProvider, float sigma,
                                                const SkRRect& rrect) {
     if (!rrect.isSimpleCircular()) {
-        return NULL;
+        return nullptr;
     }
 
     // Make sure we can successfully ninepatch this rrect -- the blur sigma has to be
     // sufficiently small relative to both the size of the corner radius and the
     // width (and height) of the rrect.
 
     unsigned int blurRadius = 3*SkScalarCeilToInt(sigma-1/6.0f);
     unsigned int cornerRadius = SkScalarCeilToInt(rrect.getSimpleRadii().x());
     if (cornerRadius + blurRadius > rrect.width()/2 ||
         cornerRadius + blurRadius > rrect.height()/2) {
-        return NULL;
+        return nullptr;
     }
 
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey key;
     GrUniqueKey::Builder builder(&key, kDomain, 2);
     builder[0] = blurRadius;
     builder[1] = cornerRadius;
     builder.finish();
 
     SkAutoTUnref<GrTexture> blurNinePatchTexture(texProvider->findAndRefTextureByUniqueKey(key));
@@ skipping 13 matching lines @@
 
         SkRect smallRect;
         smallRect.setWH(SkIntToScalar(smallRectSide), SkIntToScalar(smallRectSide));
 
         SkRRect smallRRect;
         smallRRect.setRectXY(smallRect, SkIntToScalar(cornerRadius), SkIntToScalar(cornerRadius));
 
         SkPath path;
         path.addRRect( smallRRect );
 
-        SkDraw::DrawToMask(path, &mask.fBounds, NULL, NULL, &mask,
+        SkDraw::DrawToMask(path, &mask.fBounds, nullptr, nullptr, &mask,
                            SkMask::kJustRenderImage_CreateMode, SkPaint::kFill_Style);
 
         SkMask blurredMask;
         SkBlurMask::BoxBlur(&blurredMask, mask, sigma, kNormal_SkBlurStyle, kHigh_SkBlurQuality,
-                            NULL, true );
+                            nullptr, true );
 
         unsigned int texSide = smallRectSide + 2*blurRadius;
         GrSurfaceDesc texDesc;
         texDesc.fWidth = texSide;
         texDesc.fHeight = texSide;
         texDesc.fConfig = kAlpha_8_GrPixelConfig;
 
         blurNinePatchTexture.reset(
             texProvider->createTexture(texDesc, true, blurredMask.fImage, 0));
         SkMask::FreeImage(blurredMask.fImage);
         if (!blurNinePatchTexture) {
-            return NULL;
+            return nullptr;
         }
         texProvider->assignUniqueKeyToTexture(key, blurNinePatchTexture);
     }
     return new GrRRectBlurEffect(sigma, rrect, blurNinePatchTexture);
 }
 
 void GrRRectBlurEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownSingleComponent();
 }
 
@@ skipping 176 matching lines @@
     static const SkScalar kMIN_GPU_BLUR_SIZE  = SkIntToScalar(64);
     static const SkScalar kMIN_GPU_BLUR_SIGMA = SkIntToScalar(32);
 
     if (srcBounds.width() <= kMIN_GPU_BLUR_SIZE &&
         srcBounds.height() <= kMIN_GPU_BLUR_SIZE &&
         xformedSigma <= kMIN_GPU_BLUR_SIGMA) {
         // We prefer to blur small rect with small radius via CPU.
         return false;
     }
 
-    if (NULL == maskRect) {
+    if (nullptr == maskRect) {
         // don't need to compute maskRect
         return true;
     }
 
     float sigma3 = 3 * SkScalarToFloat(xformedSigma);
 
     SkRect clipRect = SkRect::Make(clipBounds);
     SkRect srcRect(srcBounds);
 
     // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area.
@@ skipping 16 matching lines @@
     GrContext* context = src->getContext();
 
     SkScalar xformedSigma = this->computeXformedSigma(ctm);
     SkASSERT(xformedSigma > 0);
 
     // If we're doing a normal blur, we can clobber the pathTexture in the
     // gaussianBlur.  Otherwise, we need to save it for later compositing.
     bool isNormalBlur = (kNormal_SkBlurStyle == fBlurStyle);
     *result = SkGpuBlurUtils::GaussianBlur(context, src, isNormalBlur && canOverwriteSrc,
                                            clipRect, false, xformedSigma, xformedSigma);
-    if (NULL == *result) {
+    if (nullptr == *result) {
         return false;
     }
 
     if (!isNormalBlur) {
         GrPaint paint;
         SkMatrix matrix;
         matrix.setIDiv(src->width(), src->height());
         // Blend pathTexture over blurTexture.
         paint.addCoverageFragmentProcessor(
             GrSimpleTextureEffect::Create(paint.getProcessorDataManager(), src, matrix))->unref();
@@ skipping 50 matching lines @@
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END