Style Change: NULL->nullptr

src/core/SkDevice.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 "SkColorFilter.h"
 #include "SkDevice.h"
 #include "SkDraw.h"
 #include "SkDrawFilter.h"
 #include "SkImage_Base.h"
 #include "SkMetaData.h"
 #include "SkNinePatchIter.h"
 #include "SkPatchUtils.h"
 #include "SkPathMeasure.h"
 #include "SkRasterClip.h"
 #include "SkRSXform.h"
 #include "SkShader.h"
 #include "SkTextBlob.h"
 #include "SkTextToPathIter.h"
 
 SkBaseDevice::SkBaseDevice(const SkSurfaceProps& surfaceProps)
     : fSurfaceProps(surfaceProps)
 #ifdef SK_DEBUG
     , fAttachedToCanvas(false)
 #endif
 {
     fOrigin.setZero();
-    fMetaData = NULL;
+    fMetaData = nullptr;
 }
 
 SkBaseDevice::~SkBaseDevice() { delete fMetaData; }
 
 SkMetaData& SkBaseDevice::getMetaData() {
     // metadata users are rare, so we lazily allocate it. If that changes we
     // can decide to just make it a field in the device (rather than a ptr)
-    if (NULL == fMetaData) {
+    if (nullptr == fMetaData) {
         fMetaData = new SkMetaData;
     }
     return *fMetaData;
 }
 
 SkImageInfo SkBaseDevice::imageInfo() const {
     return SkImageInfo::MakeUnknown();
 }
 
 const SkBitmap& SkBaseDevice::accessBitmap(bool changePixels) {
@@ skipping 22 matching lines @@
     return geo;
 }
 
 void SkBaseDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
                               const SkRRect& inner, const SkPaint& paint) {
     SkPath path;
     path.addRRect(outer);
     path.addRRect(inner);
     path.setFillType(SkPath::kEvenOdd_FillType);
 
-    const SkMatrix* preMatrix = NULL;
+    const SkMatrix* preMatrix = nullptr;
     const bool pathIsMutable = true;
     this->drawPath(draw, path, paint, preMatrix, pathIsMutable);
 }
 
 void SkBaseDevice::drawPatch(const SkDraw& draw, const SkPoint cubics[12], const SkColor colors[4],
                              const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
     SkPatchUtils::VertexData data;
     
     SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, draw.fMatrix);
 
@@ skipping 113 matching lines @@
         pnt.setShader(shader);
 
         if (colors && colors[i] != SK_ColorWHITE) {
             SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(colors[i], mode));
             pnt.setColorFilter(cf);
         }
         
         path.rewind();
         path.addPoly(quad, 4, true);
         path.setConvexity(SkPath::kConvex_Convexity);
-        this->drawPath(draw, path, pnt, NULL, true);
+        this->drawPath(draw, path, pnt, nullptr, true);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 bool SkBaseDevice::readPixels(const SkImageInfo& info, void* dstP, size_t rowBytes, int x, int y) {
 #ifdef SK_DEBUG
     SkASSERT(info.width() > 0 && info.height() > 0);
     SkASSERT(dstP);
     SkASSERT(rowBytes >= info.minRowBytes());
@@ skipping 30 matching lines @@
 }
 
 bool SkBaseDevice::EXPERIMENTAL_drawPicture(SkCanvas*, const SkPicture*, const SkMatrix*,
                                             const SkPaint*) {
     // The base class doesn't perform any accelerated picture rendering
     return false;
 }
 
 bool SkBaseDevice::accessPixels(SkPixmap* pmap) {
     SkPixmap tempStorage;
-    if (NULL == pmap) {
+    if (nullptr == pmap) {
         pmap = &tempStorage;
     }
     return this->onAccessPixels(pmap);
 }
 
 bool SkBaseDevice::peekPixels(SkPixmap* pmap) {
     SkPixmap tempStorage;
-    if (NULL == pmap) {
+    if (nullptr == pmap) {
         pmap = &tempStorage;
     }
     return this->onPeekPixels(pmap);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
 static void morphpoints(SkPoint dst[], const SkPoint src[], int count,
                         SkPathMeasure& meas, const SkMatrix& matrix) {
     SkMatrix::MapXYProc proc = matrix.getMapXYProc();
@@ skipping 65 matching lines @@
             default:
                 SkDEBUGFAIL("unknown verb");
                 break;
         }
     }
 }
 
 void SkBaseDevice::drawTextOnPath(const SkDraw& draw, const void* text, size_t byteLength,
                                   const SkPath& follow, const SkMatrix* matrix,
                                   const SkPaint& paint) {
-    SkASSERT(byteLength == 0 || text != NULL);
+    SkASSERT(byteLength == 0 || text != nullptr);
     
     // nothing to draw
-    if (text == NULL || byteLength == 0 || draw.fRC->isEmpty()) {
+    if (text == nullptr || byteLength == 0 || draw.fRC->isEmpty()) {
         return;
     }
     
     SkTextToPathIter    iter((const char*)text, byteLength, paint, true);
     SkPathMeasure       meas(follow, false);
     SkScalar            hOffset = 0;
     
     // need to measure first
     if (paint.getTextAlign() != SkPaint::kLeft_Align) {
         SkScalar pathLen = meas.getLength();
@@ skipping 14 matching lines @@
         if (iterPath) {
             SkPath      tmp;
             SkMatrix    m(scaledMatrix);
             
             tmp.setIsVolatile(true);
             m.postTranslate(xpos + hOffset, 0);
             if (matrix) {
                 m.postConcat(*matrix);
             }
             morphpath(&tmp, *iterPath, meas, m);
-            this->drawPath(draw, tmp, iter.getPaint(), NULL, true);
+            this->drawPath(draw, tmp, iter.getPaint(), nullptr, true);
         }
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
 uint32_t SkBaseDevice::filterTextFlags(const SkPaint& paint) const {
     uint32_t flags = paint.getFlags();
 
     if (!paint.isLCDRenderText() || !paint.isAntiAlias()) {
         return flags;
     }
 
     if (kUnknown_SkPixelGeometry == fSurfaceProps.pixelGeometry()
         || this->onShouldDisableLCD(paint)) {
 
         flags &= ~SkPaint::kLCDRenderText_Flag;
         flags |= SkPaint::kGenA8FromLCD_Flag;
     }
 
     return flags;
 }