Style Change: NULL->nullptr

src/core/SkBitmapProcShader.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapProcShader.h"
 #include "SkBitmapProcState.h"
 #include "SkColorPriv.h"
@@ skipping 29 matching lines @@
         xy[1] = (TileMode)fTileModeY;
     }
     return kDefault_BitmapType;
 }
 
 SkFlattenable* SkBitmapProcShader::CreateProc(SkReadBuffer& buffer) {
     SkMatrix lm;
     buffer.readMatrix(&lm);
     SkBitmap bm;
     if (!buffer.readBitmap(&bm)) {
-        return NULL;
+        return nullptr;
     }
     bm.setImmutable();
     TileMode mx = (TileMode)buffer.readUInt();
     TileMode my = (TileMode)buffer.readUInt();
     return SkShader::CreateBitmapShader(bm, mx, my, &lm);
 }
 
 void SkBitmapProcShader::flatten(SkWriteBuffer& buffer) const {
     buffer.writeMatrix(this->getLocalMatrix());
     buffer.writeBitmap(fRawBitmap);
     buffer.writeUInt(fTileModeX);
     buffer.writeUInt(fTileModeY);
 }
 
 static bool only_scale_and_translate(const SkMatrix& matrix) {
     unsigned mask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
     return (matrix.getType() & ~mask) == 0;
 }
 
 bool SkBitmapProcShader::isOpaque() const {
     return fRawBitmap.isOpaque();
 }
 
 SkShader::Context* SkBitmapProcShader::onCreateContext(const ContextRec& rec, void* storage) const {
     SkMatrix totalInverse;
     // Do this first, so we know the matrix can be inverted.
     if (!this->computeTotalInverse(rec, &totalInverse)) {
-        return NULL;
+        return nullptr;
     }
 
     void* stateStorage = (char*)storage + sizeof(BitmapProcShaderContext);
     SkBitmapProcState* state = new (stateStorage) SkBitmapProcState;
 
     SkASSERT(state);
     state->fTileModeX = fTileModeX;
     state->fTileModeY = fTileModeY;
     state->fOrigBitmap = fRawBitmap;
     if (!state->chooseProcs(totalInverse, *rec.fPaint)) {
         state->~SkBitmapProcState();
-        return NULL;
+        return nullptr;
     }
 
     return new (storage) BitmapProcShaderContext(*this, rec, state);
 }
 
 size_t SkBitmapProcShader::contextSize() const {
     // The SkBitmapProcState is stored outside of the context object, with the context holding
     // a pointer to it.
     return sizeof(BitmapProcShaderContext) + sizeof(SkBitmapProcState);
 }
@@ skipping 104 matching lines @@
         x += n;
         dstC += n;
     }
 }
 
 SkShader::Context::ShadeProc SkBitmapProcShader::BitmapProcShaderContext::asAShadeProc(void** ctx) {
     if (fState->getShaderProc32()) {
         *ctx = fState;
         return (ShadeProc)fState->getShaderProc32();
     }
-    return NULL;
+    return nullptr;
 }
 
 void SkBitmapProcShader::BitmapProcShaderContext::shadeSpan16(int x, int y, uint16_t dstC[],
                                                               int count) {
     const SkBitmapProcState& state = *fState;
     if (state.getShaderProc16()) {
         state.getShaderProc16()(state, x, y, dstC, count);
         return;
     }
 
@@ skipping 68 matching lines @@
 
     return bm.width() > kMaxSize || bm.height() > kMaxSize;
 }
 
 SkShader* SkCreateBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
                                SkShader::TileMode tmy, const SkMatrix* localMatrix,
                                SkTBlitterAllocator* allocator) {
     SkShader* shader;
     SkColor color;
     if (src.isNull() || bitmap_is_too_big(src)) {
-        if (NULL == allocator) {
+        if (nullptr == allocator) {
             shader = new SkEmptyShader;
         } else {
             shader = allocator->createT<SkEmptyShader>();
         }
     } else if (can_use_color_shader(src, &color)) {
-        if (NULL == allocator) {
+        if (nullptr == allocator) {
             shader = new SkColorShader(color);
         } else {
             shader = allocator->createT<SkColorShader>(color);
         }
     } else {
-        if (NULL == allocator) {
+        if (nullptr == allocator) {
             shader = new SkBitmapProcShader(src, tmx, tmy, localMatrix);
         } else {
             shader = allocator->createT<SkBitmapProcShader>(src, tmx, tmy, localMatrix);
         }
     }
     return shader;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 85 matching lines @@
 #else
 
 bool SkBitmapProcShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
                                              const SkMatrix*, GrColor*, GrProcessorDataManager*,
                                              GrFragmentProcessor**) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 
 #endif