Style Change: NULL->nullptr

src/effects/gradients/SkGradientShader.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 "SkGradientShaderPriv.h"
 #include "SkLinearGradient.h"
 #include "SkRadialGradient.h"
@@ skipping 31 matching lines @@
     }
 
     if (!buffer.readColorArray(const_cast<SkColor*>(fColors), fCount)) {
         return false;
     }
     if (buffer.readBool()) {
         if (!buffer.readScalarArray(const_cast<SkScalar*>(fPos), fCount)) {
             return false;
         }
     } else {
-        fPos = NULL;
+        fPos = nullptr;
     }
 
     fTileMode = (SkShader::TileMode)buffer.read32();
     fGradFlags = buffer.read32();
 
     if (buffer.readBool()) {
         fLocalMatrix = &fLocalMatrixStorage;
         buffer.readMatrix(&fLocalMatrixStorage);
     } else {
-        fLocalMatrix = NULL;
+        fLocalMatrix = nullptr;
     }
     return buffer.isValid();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 
 SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc, const SkMatrix& ptsToUnit)
     : INHERITED(desc.fLocalMatrix)
     , fPtsToUnit(ptsToUnit)
 {
@@ skipping 50 matching lines @@
         if (dummyLast) {
             origColors += desc.fCount;
             *origColors = desc.fColors[desc.fCount - 1];
         }
     }
 
     if (desc.fPos && fColorCount) {
         fOrigPos = (SkScalar*)(fOrigColors + fColorCount);
         fRecs = (Rec*)(fOrigPos + fColorCount);
     } else {
-        fOrigPos = NULL;
+        fOrigPos = nullptr;
         fRecs = (Rec*)(fOrigColors + fColorCount);
     }
 
     if (fColorCount > 2) {
         Rec* recs = fRecs;
         recs->fPos = 0;
         //  recs->fScale = 0; // unused;
         recs += 1;
         if (desc.fPos) {
             SkScalar* origPosPtr = fOrigPos;
@@ skipping 24 matching lines @@
                 if (diff > 0) {
                     recs->fScale = (1 << 24) / diff;
                 } else {
                     recs->fScale = 0; // ignore this segment
                 }
                 // get ready for the next value
                 prev = curr;
                 recs += 1;
             }
         } else {    // assume even distribution
-            fOrigPos = NULL;
+            fOrigPos = nullptr;
 
             SkFixed dp = SK_Fixed1 / (desc.fCount - 1);
             SkFixed p = dp;
             SkFixed scale = (desc.fCount - 1) << 8;  // (1 << 24) / dp
             for (int i = 1; i < desc.fCount - 1; i++) {
                 recs->fPos   = p;
                 recs->fScale = scale;
                 recs += 1;
                 p += dp;
             }
             recs->fPos = SK_Fixed1;
             recs->fScale = scale;
         }
     } else if (desc.fPos) {
         SkASSERT(2 == fColorCount);
         fOrigPos[0] = SkScalarPin(desc.fPos[0], 0, 1);
         fOrigPos[1] = SkScalarPin(desc.fPos[1], fOrigPos[0], 1);
         if (0 == fOrigPos[0] && 1 == fOrigPos[1]) {
-            fOrigPos = NULL;
+            fOrigPos = nullptr;
         }
     }
     this->initCommon();
 }
 
 SkGradientShaderBase::~SkGradientShaderBase() {
     if (fOrigColors != fStorage) {
         sk_free(fOrigColors);
     }
 }
 
 void SkGradientShaderBase::initCommon() {
     unsigned colorAlpha = 0xFF;
     for (int i = 0; i < fColorCount; i++) {
         colorAlpha &= SkColorGetA(fOrigColors[i]);
     }
     fColorsAreOpaque = colorAlpha == 0xFF;
 }
 
 void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const {
     Descriptor desc;
     desc.fColors = fOrigColors;
     desc.fPos = fOrigPos;
     desc.fCount = fColorCount;
     desc.fTileMode = fTileMode;
     desc.fGradFlags = fGradFlags;
 
     const SkMatrix& m = this->getLocalMatrix();
-    desc.fLocalMatrix = m.isIdentity() ? NULL : &m;
+    desc.fLocalMatrix = m.isIdentity() ? nullptr : &m;
     desc.flatten(buffer);
 }
 
 SkGradientShaderBase::GpuColorType SkGradientShaderBase::getGpuColorType(SkColor colors[3]) const {
     if (fColorCount <= 3) {
         memcpy(colors, fOrigColors, fColorCount * sizeof(SkColor));
     }
 
     if (SkShader::kClamp_TileMode == fTileMode) {
         if (2 == fColorCount) {
@@ skipping 80 matching lines @@
 }
 
 SkGradientShaderBase::GradientShaderCache::GradientShaderCache(
         U8CPU alpha, const SkGradientShaderBase& shader)
     : fCacheAlpha(alpha)
     , fShader(shader)
     , fCache16Inited(false)
     , fCache32Inited(false)
 {
     // Only initialize the cache in getCache16/32.
-    fCache16 = NULL;
-    fCache32 = NULL;
-    fCache16Storage = NULL;
-    fCache32PixelRef = NULL;
+    fCache16 = nullptr;
+    fCache32 = nullptr;
+    fCache16Storage = nullptr;
+    fCache32PixelRef = nullptr;
 }
 
 SkGradientShaderBase::GradientShaderCache::~GradientShaderCache() {
     sk_free(fCache16Storage);
     SkSafeUnref(fCache32PixelRef);
 }
 
 #define Fixed_To_Dot8(x)        (((x) + 0x80) >> 8)
 
 /** We take the original colors, not our premultiplied PMColors, since we can
@@ skipping 187 matching lines @@
            this);
     SkASSERT(fCache16);
     return fCache16;
 }
 
 void SkGradientShaderBase::GradientShaderCache::initCache16(GradientShaderCache* cache) {
     // double the count for dither entries
     const int entryCount = kCache16Count * 2;
     const size_t allocSize = sizeof(uint16_t) * entryCount;
 
-    SkASSERT(NULL == cache->fCache16Storage);
+    SkASSERT(nullptr == cache->fCache16Storage);
     cache->fCache16Storage = (uint16_t*)sk_malloc_throw(allocSize);
     cache->fCache16 = cache->fCache16Storage;
     if (cache->fShader.fColorCount == 2) {
         Build16bitCache(cache->fCache16, cache->fShader.fOrigColors[0],
                         cache->fShader.fOrigColors[1], kCache16Count);
     } else {
         Rec* rec = cache->fShader.fRecs;
         int prevIndex = 0;
         for (int i = 1; i < cache->fShader.fColorCount; i++) {
             int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache16Shift;
@@ skipping 11 matching lines @@
     SkOnce(&fCache32Inited, &fCache32Mutex, SkGradientShaderBase::GradientShaderCache::initCache32,
            this);
     SkASSERT(fCache32);
     return fCache32;
 }
 
 void SkGradientShaderBase::GradientShaderCache::initCache32(GradientShaderCache* cache) {
     const int kNumberOfDitherRows = 4;
     const SkImageInfo info = SkImageInfo::MakeN32Premul(kCache32Count, kNumberOfDitherRows);
 
-    SkASSERT(NULL == cache->fCache32PixelRef);
-    cache->fCache32PixelRef = SkMallocPixelRef::NewAllocate(info, 0, NULL);
+    SkASSERT(nullptr == cache->fCache32PixelRef);
+    cache->fCache32PixelRef = SkMallocPixelRef::NewAllocate(info, 0, nullptr);
     cache->fCache32 = (SkPMColor*)cache->fCache32PixelRef->getAddr();
     if (cache->fShader.fColorCount == 2) {
         Build32bitCache(cache->fCache32, cache->fShader.fOrigColors[0],
                         cache->fShader.fOrigColors[1], kCache32Count, cache->fCacheAlpha,
                         cache->fShader.fGradFlags);
     } else {
         Rec* rec = cache->fShader.fRecs;
         int prevIndex = 0;
         for (int i = 1; i < cache->fShader.fColorCount; i++) {
             int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache32Shift;
@@ skipping 58 matching lines @@
     *buffer++ = fGradFlags;
     SkASSERT(buffer - storage.get() == count);
 
     ///////////////////////////////////
 
     static SkGradientBitmapCache* gCache;
     // each cache cost 1K of RAM, since each bitmap will be 1x256 at 32bpp
     static const int MAX_NUM_CACHED_GRADIENT_BITMAPS = 32;
     SkAutoMutexAcquire ama(gGradientCacheMutex);
 
-    if (NULL == gCache) {
+    if (nullptr == gCache) {
         gCache = new SkGradientBitmapCache(MAX_NUM_CACHED_GRADIENT_BITMAPS);
     }
     size_t size = count * sizeof(int32_t);
 
     if (!gCache->find(storage.get(), size, bitmap)) {
         // force our cahce32pixelref to be built
         (void)cache->getCache32();
         bitmap->setInfo(SkImageInfo::MakeN32Premul(kCache32Count, 1));
         bitmap->setPixelRef(cache->getCache32PixelRef());
 
@@ skipping 69 matching lines @@
     this->INHERITED::toString(str);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 // Return true if these parameters are valid/legal/safe to construct a gradient
 //
 static bool valid_grad(const SkColor colors[], const SkScalar pos[], int count, unsigned tileMode) {
-    return NULL != colors && count >= 1 && tileMode < (unsigned)SkShader::kTileModeCount;
+    return nullptr != colors && count >= 1 && tileMode < (unsigned)SkShader::kTileModeCount;
 }
 
 // assumes colors is SkColor* and pos is SkScalar*
 #define EXPAND_1_COLOR(count)               \
     SkColor tmp[2];                         \
     do {                                    \
         if (1 == count) {                   \
             tmp[0] = tmp[1] = colors[0];    \
             colors = tmp;                   \
-            pos = NULL;                     \
+            pos = nullptr;                     \
             count = 2;                      \
         }                                   \
     } while (0)
 
 static void desc_init(SkGradientShaderBase::Descriptor* desc,
                       const SkColor colors[], const SkScalar pos[], int colorCount,
                       SkShader::TileMode mode, uint32_t flags, const SkMatrix* localMatrix) {
     desc->fColors       = colors;
     desc->fPos          = pos;
     desc->fCount        = colorCount;
     desc->fTileMode     = mode;
     desc->fGradFlags    = flags;
     desc->fLocalMatrix  = localMatrix;
 }
 
 SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2],
                                          const SkColor colors[],
                                          const SkScalar pos[], int colorCount,
                                          SkShader::TileMode mode,
                                          uint32_t flags,
                                          const SkMatrix* localMatrix) {
     if (!pts) {
-        return NULL;
+        return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
-        return NULL;
+        return nullptr;
     }
     EXPAND_1_COLOR(colorCount);
 
     SkGradientShaderBase::Descriptor desc;
     desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
     return new SkLinearGradient(pts, desc);
 }
 
 SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius,
                                          const SkColor colors[],
                                          const SkScalar pos[], int colorCount,
                                          SkShader::TileMode mode,
                                          uint32_t flags,
                                          const SkMatrix* localMatrix) {
     if (radius <= 0) {
-        return NULL;
+        return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
-        return NULL;
+        return nullptr;
     }
     EXPAND_1_COLOR(colorCount);
 
     SkGradientShaderBase::Descriptor desc;
     desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
     return new SkRadialGradient(center, radius, desc);
 }
 
 SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start,
                                                   SkScalar startRadius,
                                                   const SkPoint& end,
                                                   SkScalar endRadius,
                                                   const SkColor colors[],
                                                   const SkScalar pos[],
                                                   int colorCount,
                                                   SkShader::TileMode mode,
                                                   uint32_t flags,
                                                   const SkMatrix* localMatrix) {
     if (startRadius < 0 || endRadius < 0) {
-        return NULL;
+        return nullptr;
     }
     if (!valid_grad(colors, pos, colorCount, mode)) {
-        return NULL;
+        return nullptr;
     }
     if (start == end && startRadius == endRadius) {
         return SkShader::CreateEmptyShader();
     }
 
     EXPAND_1_COLOR(colorCount);
 
     bool flipGradient = startRadius > endRadius;
 
     SkGradientShaderBase::Descriptor desc;
 
     if (!flipGradient) {
         desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix);
         return new SkTwoPointConicalGradient(start, startRadius, end, endRadius, flipGradient,
                                              desc);
     } else {
         SkAutoSTArray<8, SkColor> colorsNew(colorCount);
         SkAutoSTArray<8, SkScalar> posNew(colorCount);
         for (int i = 0; i < colorCount; ++i) {
             colorsNew[i] = colors[colorCount - i - 1];
         }
 
         if (pos) {
             for (int i = 0; i < colorCount; ++i) {
                 posNew[i] = 1 - pos[colorCount - i - 1];
             }
             desc_init(&desc, colorsNew.get(), posNew.get(), colorCount, mode, flags, localMatrix);
         } else {
-            desc_init(&desc, colorsNew.get(), NULL, colorCount, mode, flags, localMatrix);
+            desc_init(&desc, colorsNew.get(), nullptr, colorCount, mode, flags, localMatrix);
         }
 
         return new SkTwoPointConicalGradient(end, endRadius, start, startRadius, flipGradient,
                                              desc);
     }
 }
 
 SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy,
                                         const SkColor colors[],
                                         const SkScalar pos[],
                                         int colorCount,
                                         uint32_t flags,
                                         const SkMatrix* localMatrix) {
     if (!valid_grad(colors, pos, colorCount, SkShader::kClamp_TileMode)) {
-        return NULL;
+        return nullptr;
     }
     EXPAND_1_COLOR(colorCount);
 
     SkGradientShaderBase::Descriptor desc;
     desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags, localMatrix);
     return new SkSweepGradient(cx, cy, desc);
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient)
@@ skipping 288 matching lines @@
 }
 
 int GrGradientEffect::RandomGradientParams(SkRandom* random,
                                            SkColor colors[],
                                            SkScalar** stops,
                                            SkShader::TileMode* tm) {
     int outColors = random->nextRangeU(1, kMaxRandomGradientColors);
 
     // if one color, omit stops, otherwise randomly decide whether or not to
     if (outColors == 1 || (outColors >= 2 && random->nextBool())) {
-        *stops = NULL;
+        *stops = nullptr;
     }
 
     SkScalar stop = 0.f;
     for (int i = 0; i < outColors; ++i) {
         colors[i] = random->nextU();
         if (*stops) {
             (*stops)[i] = stop;
             stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f;
         }
     }
     *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount));
 
     return outColors;
 }
 
 #endif