Style Change: NULL->nullptr

src/gpu/GrSWMaskHelper.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrSWMaskHelper.h"
 
 #include "GrPipelineBuilder.h"
@@ skipping 52 matching lines @@
             // Best guess
             config = kAlpha_8_GrPixelConfig;
             break;
     }
 
     return config;
 }
 
 static bool choose_compressed_fmt(const GrCaps* caps,
                                   SkTextureCompressor::Format *fmt) {
-    if (NULL == fmt) {
+    if (nullptr == fmt) {
         return false;
     }
 
     // We can't use scratch textures without the ability to update
     // compressed textures...
     if (!(caps->compressedTexSubImageSupport())) {
         return false;
     }
 
     // Figure out what our preferred texture type is. If ASTC is available, that always
@@ skipping 51 matching lines @@
         } else {
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setStrokeJoin(stroke.getJoin());
             paint.setStrokeCap(stroke.getCap());
             paint.setStrokeWidth(stroke.getWidth());
         }
     }
     paint.setAntiAlias(antiAlias);
 
     SkTBlitterAllocator allocator;
-    SkBlitter* blitter = NULL;
+    SkBlitter* blitter = nullptr;
     if (kBlitter_CompressionMode == fCompressionMode) {
         SkASSERT(fCompressedBuffer.get());
         blitter = SkTextureCompressor::CreateBlitterForFormat(
             fPixels.width(), fPixels.height(), fCompressedBuffer.get(), &allocator,
                                                               fCompressedFormat);
     }
 
     if (SkRegion::kReplace_Op == op && 0xFF == alpha) {
         SkASSERT(0xFF == paint.getAlpha());
         fDraw.drawPathCoverage(path, paint, blitter);
@@ skipping 34 matching lines @@
         SkTextureCompressor::GetBlockDimensions(fCompressedFormat, &dimX, &dimY);
         cmpWidth = dimX * ((cmpWidth + (dimX - 1)) / dimX);
         cmpHeight = dimY * ((cmpHeight + (dimY - 1)) / dimY);
 
         // Can we create a blitter?
         if (SkTextureCompressor::ExistsBlitterForFormat(fCompressedFormat)) {
             int cmpSz = SkTextureCompressor::GetCompressedDataSize(
                 fCompressedFormat, cmpWidth, cmpHeight);
 
             SkASSERT(cmpSz > 0);
-            SkASSERT(NULL == fCompressedBuffer.get());
+            SkASSERT(nullptr == fCompressedBuffer.get());
             fCompressedBuffer.reset(cmpSz);
             fCompressionMode = kBlitter_CompressionMode;
         }
     } 
 
     sk_bzero(&fDraw, sizeof(fDraw));
 
     // If we don't have a custom blitter, then we either need a bitmap to compress
     // from or a bitmap that we're going to use as a texture. In any case, we should
     // allocate the pixels for a bitmap
@@ skipping 41 matching lines @@
 }
 
 void GrSWMaskHelper::sendTextureData(GrTexture *texture, const GrSurfaceDesc& desc,
                                      const void *data, size_t rowbytes) {
     // If we aren't reusing scratch textures we don't need to flush before
     // writing since no one else will be using 'texture'
     bool reuseScratch = fContext->caps()->reuseScratchTextures();
 
     // Since we're uploading to it, and it's compressed, 'texture' shouldn't
     // have a render target.
-    SkASSERT(NULL == texture->asRenderTarget());
+    SkASSERT(nullptr == texture->asRenderTarget());
 
     texture->writePixels(0, 0, desc.fWidth, desc.fHeight,
                          desc.fConfig, data, rowbytes,
                          reuseScratch ? 0 : GrContext::kDontFlush_PixelOpsFlag);
 }
 
 void GrSWMaskHelper::compressTextureData(GrTexture *texture, const GrSurfaceDesc& desc) {
 
     SkASSERT(GrPixelConfigIsCompressed(desc.fConfig));
     SkASSERT(fmt_to_config(fCompressedFormat) == desc.fConfig);
@@ skipping 36 matching lines @@
  */
 void GrSWMaskHelper::toSDF(unsigned char* sdf) {
     SkGenerateDistanceFieldFromA8Image(sdf, (const unsigned char*)fPixels.addr(),
                                        fPixels.width(), fPixels.height(), fPixels.rowBytes());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 /**
  * Software rasterizes path to A8 mask (possibly using the context's matrix)
  * and uploads the result to a scratch texture. Returns the resulting
- * texture on success; NULL on failure.
+ * texture on success; nullptr on failure.
  */
 GrTexture* GrSWMaskHelper::DrawPathMaskToTexture(GrContext* context,
                                                  const SkPath& path,
                                                  const SkStrokeRec& stroke,
                                                  const SkIRect& resultBounds,
                                                  bool antiAlias,
                                                  const SkMatrix* matrix) {
     GrSWMaskHelper helper(context);
 
     if (!helper.init(resultBounds, matrix)) {
-        return NULL;
+        return nullptr;
     }
 
     helper.draw(path, stroke, SkRegion::kReplace_Op, antiAlias, 0xFF);
 
     GrTexture* texture(helper.createTexture());
     if (!texture) {
-        return NULL;
+        return nullptr;
     }
 
     helper.toTexture(texture);
 
     return texture;
 }
 
 void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture,
                                               GrDrawTarget* target,
                                               GrPipelineBuilder* pipelineBuilder,
@@ skipping 20 matching lines @@
 
     pipelineBuilder->addCoverageFragmentProcessor(
                          GrSimpleTextureEffect::Create(pipelineBuilder->getProcessorDataManager(),
                                                        texture,
                                                        maskMatrix,
                                                        GrTextureParams::kNone_FilterMode,
                                                        kDevice_GrCoordSet))->unref();
 
     target->drawNonAARect(*pipelineBuilder, color, SkMatrix::I(), dstRect, invert);
 }