Style Change: NULL->nullptr

src/core/SkPictureShader.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPictureShader.h"
 
 #include "SkBitmap.h"
@@ skipping 67 matching lines @@
     const char* getCategory() const override { return "bitmap-shader"; }
     SkDiscardableMemory* diagnostic_only_getDiscardable() const override { return nullptr; }
 
     static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextShader) {
         const BitmapShaderRec& rec = static_cast<const BitmapShaderRec&>(baseRec);
         SkAutoTUnref<SkShader>* result = reinterpret_cast<SkAutoTUnref<SkShader>*>(contextShader);
 
         result->reset(SkRef(rec.fShader.get()));
 
         SkBitmap tile;
-        if (rec.fShader.get()->isABitmap(&tile, NULL, NULL)) {
+        if (rec.fShader.get()->isABitmap(&tile, nullptr, nullptr)) {
             // FIXME: this doesn't protect the pixels from being discarded as soon as we unlock.
             // Should be handled via a pixel ref generator instead
             // (https://code.google.com/p/skia/issues/detail?id=3220).
             SkAutoLockPixels alp(tile, true);
-            return tile.getPixels() != NULL;
+            return tile.getPixels() != nullptr;
         }
         return false;
     }
 };
 
 static bool cache_try_alloc_pixels(SkBitmap* bitmap) {
     SkBitmap::Allocator* allocator = SkResourceCache::GetAllocator();
 
-    return NULL != allocator
-        ? allocator->allocPixelRef(bitmap, NULL)
+    return nullptr != allocator
+        ? allocator->allocPixelRef(bitmap, nullptr)
         : bitmap->tryAllocPixels();
 }
 
 } // namespace
 
 SkPictureShader::SkPictureShader(const SkPicture* picture, TileMode tmx, TileMode tmy,
                                  const SkMatrix* localMatrix, const SkRect* tile)
     : INHERITED(localMatrix)
     , fPicture(SkRef(picture))
     , fTile(tile ? *tile : picture->cullRect())
@@ skipping 20 matching lines @@
     TileMode my = (TileMode)buffer.read32();
     SkRect tile;
     buffer.readRect(&tile);
 
     SkAutoTUnref<SkPicture> picture;
 
     if (buffer.isCrossProcess() && SkPicture::PictureIOSecurityPrecautionsEnabled()) {
         if (buffer.isVersionLT(SkReadBuffer::kPictureShaderHasPictureBool_Version)) {
             // Older code blindly serialized pictures.  We don't trust them.
             buffer.validate(false);
-            return NULL;
+            return nullptr;
         }
         // Newer code won't serialize pictures in disallow-cross-process-picture mode.
         // Assert that they didn't serialize anything except a false here.
         buffer.validate(!buffer.readBool());
     } else {
         // Old code always serialized the picture.  New code writes a 'true' first if it did.
         if (buffer.isVersionLT(SkReadBuffer::kPictureShaderHasPictureBool_Version) ||
             buffer.readBool()) {
             picture.reset(SkPicture::CreateFromBuffer(buffer));
         }
@@ skipping 25 matching lines @@
     m.setConcat(matrix, this->getLocalMatrix());
     if (localM) {
         m.preConcat(*localM);
     }
 
     // Use a rotation-invariant scale
     SkPoint scale;
     //
     // TODO: replace this with decomposeScale() -- but beware LayoutTest rebaselines!
     //
-    if (!SkDecomposeUpper2x2(m, NULL, &scale, NULL)) {
+    if (!SkDecomposeUpper2x2(m, nullptr, &scale, nullptr)) {
         // Decomposition failed, use an approximation.
         scale.set(SkScalarSqrt(m.getScaleX() * m.getScaleX() + m.getSkewX() * m.getSkewX()),
                   SkScalarSqrt(m.getScaleY() * m.getScaleY() + m.getSkewY() * m.getSkewY()));
     }
     SkSize scaledSize = SkSize::Make(SkScalarAbs(scale.x() * fTile.width()),
                                      SkScalarAbs(scale.y() * fTile.height()));
 
     // Clamp the tile size to about 4M pixels
     static const SkScalar kMaxTileArea = 2048 * 2048;
     SkScalar tileArea = SkScalarMul(scaledSize.width(), scaledSize.height());
@@ skipping 54 matching lines @@
 
     return tileShader.detach();
 }
 
 size_t SkPictureShader::contextSize() const {
     return sizeof(PictureShaderContext);
 }
 
 SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const {
     SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(*rec.fMatrix, rec.fLocalMatrix));
-    if (NULL == bitmapShader.get()) {
-        return NULL;
+    if (nullptr == bitmapShader.get()) {
+        return nullptr;
     }
     return PictureShaderContext::Create(storage, *this, rec, bitmapShader);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 SkShader::Context* SkPictureShader::PictureShaderContext::Create(void* storage,
                    const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader) {
     PictureShaderContext* ctx = new (storage) PictureShaderContext(shader, rec, bitmapShader);
-    if (NULL == ctx->fBitmapShaderContext) {
+    if (nullptr == ctx->fBitmapShaderContext) {
         ctx->~PictureShaderContext();
-        ctx = NULL;
+        ctx = nullptr;
     }
     return ctx;
 }
 
 SkPictureShader::PictureShaderContext::PictureShaderContext(
         const SkPictureShader& shader, const ContextRec& rec, SkShader* bitmapShader)
     : INHERITED(shader, rec)
     , fBitmapShader(SkRef(bitmapShader))
 {
     fBitmapShaderContextStorage = sk_malloc_throw(bitmapShader->contextSize());
@@ skipping 53 matching lines @@
                                           GrProcessorDataManager* procDataManager,
                                           GrFragmentProcessor** fp) const {
     int maxTextureSize = 0;
     if (context) {
         maxTextureSize = context->caps()->maxTextureSize();
     }
     SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize));
     if (!bitmapShader) {
         return false;
     }
-    return bitmapShader->asFragmentProcessor(context, paint, viewM, NULL, paintColor,
+    return bitmapShader->asFragmentProcessor(context, paint, viewM, nullptr, paintColor,
                                              procDataManager, fp);
 }
 #else
 bool SkPictureShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
                                           const SkMatrix*, GrColor*, GrProcessorDataManager*,
                                           GrFragmentProcessor**) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 #endif