Style Change: NULL->nullptr

tools/PictureRenderer.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 "PictureRenderer.h"
 #include "picture_utils.h"
 #include "SamplePipeControllers.h"
@@ skipping 47 matching lines @@
                            const SkString* mismatchPath,
                            const SkString* inputFilename,
                            bool useChecksumBasedFilenames,
                            bool useMultiPictureDraw) {
     this->CopyString(&fWritePath, writePath);
     this->CopyString(&fMismatchPath, mismatchPath);
     this->CopyString(&fInputFilename, inputFilename);
     fUseChecksumBasedFilenames = useChecksumBasedFilenames;
     fUseMultiPictureDraw = useMultiPictureDraw;
 
-    SkASSERT(NULL == fPicture);
-    SkASSERT(NULL == fCanvas.get());
+    SkASSERT(nullptr == fPicture);
+    SkASSERT(nullptr == fCanvas.get());
     if (fPicture || fCanvas.get()) {
         return;
     }
 
-    SkASSERT(pict != NULL);
-    if (NULL == pict) {
+    SkASSERT(pict != nullptr);
+    if (nullptr == pict) {
         return;
     }
 
     fPicture.reset(pict)->ref();
     fCanvas.reset(this->setupCanvas());
 }
 
 void PictureRenderer::CopyString(SkString* dest, const SkString* src) {
     if (src) {
         dest->set(*src);
     } else {
         dest->reset();
     }
 }
 
 class FlagsFilterCanvas : public SkPaintFilterCanvas {
 public:
     FlagsFilterCanvas(SkCanvas* canvas, PictureRenderer::DrawFilterFlags* flags)
         : INHERITED(canvas->imageInfo().width(), canvas->imageInfo().height())
         , fFlags(flags) {
         this->addCanvas(canvas);
     }
 
 protected:
     void onFilterPaint(SkPaint* paint, Type t) const override {
         paint->setFlags(paint->getFlags() & ~fFlags[t] & SkPaint::kAllFlags);
         if (PictureRenderer::kMaskFilter_DrawFilterFlag & fFlags[t]) {
             SkMaskFilter* maskFilter = paint->getMaskFilter();
             if (maskFilter) {
-                paint->setMaskFilter(NULL);
+                paint->setMaskFilter(nullptr);
             }
         }
         if (PictureRenderer::kHinting_DrawFilterFlag & fFlags[t]) {
             paint->setHinting(SkPaint::kNo_Hinting);
         } else if (PictureRenderer::kSlightHinting_DrawFilterFlag & fFlags[t]) {
             paint->setHinting(SkPaint::kSlight_Hinting);
         }
     }
 
 private:
@@ skipping 31 matching lines @@
         case kNVPR_DeviceType: {
             SkAutoTUnref<GrSurface> target;
             if (fGrContext) {
                 // create a render target to back the device
                 GrSurfaceDesc desc;
                 desc.fConfig = kSkia8888_GrPixelConfig;
                 desc.fFlags = kRenderTarget_GrSurfaceFlag;
                 desc.fWidth = width;
                 desc.fHeight = height;
                 desc.fSampleCnt = fSampleCount;
-                target.reset(fGrContext->textureProvider()->createTexture(desc, false, NULL, 0));
+                target.reset(fGrContext->textureProvider()->createTexture(desc, false, nullptr, 0));
             }
 
             uint32_t flags = fUseDFText ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
             SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
             SkAutoTUnref<SkGpuDevice> device(
                 SkGpuDevice::Create(target->asRenderTarget(), &props,
                                     SkGpuDevice::kUninit_InitContents));
             if (!device) {
-                return NULL;
+                return nullptr;
             }
             canvas.reset(new SkCanvas(device));
             break;
         }
 #endif
         default:
             SkASSERT(0);
-            return NULL;
+            return nullptr;
     }
 
     if (fHasDrawFilters) {
         if (fDrawFilters[0] & PictureRenderer::kAAClip_DrawFilterFlag) {
             canvas->setAllowSoftClip(false);
         }
 
         canvas.reset(new FlagsFilterCanvas(canvas.get(), fDrawFilters));
     }
 
     this->scaleToScaleFactor(canvas);
 
     // Pictures often lie about their extent (i.e., claim to be 100x100 but
     // only ever draw to 90x100). Clear here so the undrawn portion will have
     // a consistent color
     canvas->clear(SK_ColorTRANSPARENT);
     return canvas.detach();
 }
 
 void PictureRenderer::scaleToScaleFactor(SkCanvas* canvas) {
-    SkASSERT(canvas != NULL);
+    SkASSERT(canvas != nullptr);
     if (fScaleFactor != SK_Scalar1) {
         canvas->scale(fScaleFactor, fScaleFactor);
     }
 }
 
 void PictureRenderer::end() {
     this->resetState(true);
-    fPicture.reset(NULL);
-    fCanvas.reset(NULL);
+    fPicture.reset(nullptr);
+    fCanvas.reset(nullptr);
 }
 
 int PictureRenderer::getViewWidth() {
-    SkASSERT(fPicture != NULL);
+    SkASSERT(fPicture != nullptr);
     int width = SkScalarCeilToInt(fPicture->cullRect().width() * fScaleFactor);
     if (fViewport.width() > 0) {
         width = SkMin32(width, fViewport.width());
     }
     return width;
 }
 
 int PictureRenderer::getViewHeight() {
-    SkASSERT(fPicture != NULL);
+    SkASSERT(fPicture != nullptr);
     int height = SkScalarCeilToInt(fPicture->cullRect().height() * fScaleFactor);
     if (fViewport.height() > 0) {
         height = SkMin32(height, fViewport.height());
     }
     return height;
 }
 
 /** Converts fPicture to a picture that uses a BBoxHierarchy.
  *  PictureRenderer subclasses that are used to test picture playback
  *  should call this method during init.
@@ skipping 12 matching lines @@
                                                    factory.get(),
                                                    flags);
         fPicture->playback(canvas);
         fPicture.reset(recorder.endRecording());
     }
 }
 
 void PictureRenderer::resetState(bool callFinish) {
 #if SK_SUPPORT_GPU
     SkGLContext* glContext = this->getGLContext();
-    if (NULL == glContext) {
+    if (nullptr == glContext) {
         SkASSERT(kBitmap_DeviceType == fDeviceType);
         return;
     }
 
     fGrContext->flush();
     glContext->swapBuffers();
     if (callFinish) {
         SK_GL(*glContext, Finish());
     }
 #endif
 }
 
 void PictureRenderer::purgeTextures() {
     SkDiscardableMemoryPool* pool = SkGetGlobalDiscardableMemoryPool();
 
     pool->dumpPool();
 
 #if SK_SUPPORT_GPU
     SkGLContext* glContext = this->getGLContext();
-    if (NULL == glContext) {
+    if (nullptr == glContext) {
         SkASSERT(kBitmap_DeviceType == fDeviceType);
         return;
     }
 
     // resetState should've already done this
     fGrContext->flush();
 
     fGrContext->purgeAllUnlockedResources();
 #endif
 }
 
 /**
  * Write the canvas to an image file and/or JSON summary.
  *
  * @param canvas Must be non-null. Canvas to be written to a file.
  * @param writePath If nonempty, write the binary image to a file within this directory.
  * @param mismatchPath If nonempty, write the binary image to a file within this directory,
  *     but only if the image does not match expectations.
  * @param inputFilename If we are writing out a binary image, use this to build its filename.
  * @param jsonSummaryPtr If not null, add image results (checksum) to this summary.
  * @param useChecksumBasedFilenames If true, use checksum-based filenames when writing to disk.
  * @param tileNumberPtr If not null, which tile number this image contains.
  *
  * @return bool True if the operation completed successfully.
  */
 static bool write(SkCanvas* canvas, const SkString& writePath, const SkString& mismatchPath,
                   const SkString& inputFilename, ImageResultsAndExpectations *jsonSummaryPtr,
-                  bool useChecksumBasedFilenames, const int* tileNumberPtr=NULL) {
-    SkASSERT(canvas != NULL);
-    if (NULL == canvas) {
+                  bool useChecksumBasedFilenames, const int* tileNumberPtr=nullptr) {
+    SkASSERT(canvas != nullptr);
+    if (nullptr == canvas) {
         return false;
     }
 
     SkBitmap bitmap;
     SkISize size = canvas->getDeviceSize();
     setup_bitmap(&bitmap, size.width(), size.height());
 
     canvas->readPixels(&bitmap, 0, 0);
     force_all_opaque(bitmap);
     BitmapAndDigest bitmapAndDigest(bitmap);
 
     SkString escapedInputFilename(inputFilename);
     replace_char(&escapedInputFilename, '.', '_');
 
     // TODO(epoger): what about including the config type within outputFilename?  That way,
     // we could combine results of different config types without conflicting filenames.
     SkString outputFilename;
-    const char *outputSubdirPtr = NULL;
+    const char *outputSubdirPtr = nullptr;
     if (useChecksumBasedFilenames) {
         ImageDigest *imageDigestPtr = bitmapAndDigest.getImageDigestPtr();
         outputSubdirPtr = escapedInputFilename.c_str();
         outputFilename.set(imageDigestPtr->getHashType());
         outputFilename.append("_");
         outputFilename.appendU64(imageDigestPtr->getHashValue());
     } else {
         outputFilename.set(escapedInputFilename);
         if (tileNumberPtr) {
             outputFilename.append("-tile");
@@ skipping 28 matching lines @@
         return true;
     } else {
         return write_bitmap_to_disk(bitmap, writePath, outputSubdirPtr, outputFilename);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 SkCanvas* RecordPictureRenderer::setupCanvas(int width, int height) {
     // defer the canvas setup until the render step
-    return NULL;
+    return nullptr;
 }
 
 bool RecordPictureRenderer::render(SkBitmap** out) {
     SkAutoTDelete<SkBBHFactory> factory(this->getFactory());
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(this->getViewWidth()),
                                                SkIntToScalar(this->getViewHeight()),
                                                factory.get(),
                                                this->recordFlags());
     this->scaleToScaleFactor(canvas);
@@ skipping 10 matching lines @@
     return false;
 }
 
 SkString RecordPictureRenderer::getConfigNameInternal() {
     return SkString("record");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 bool PipePictureRenderer::render(SkBitmap** out) {
-    SkASSERT(fCanvas.get() != NULL);
-    SkASSERT(fPicture != NULL);
-    if (NULL == fCanvas.get() || NULL == fPicture) {
+    SkASSERT(fCanvas.get() != nullptr);
+    SkASSERT(fPicture != nullptr);
+    if (nullptr == fCanvas.get() || nullptr == fPicture) {
         return false;
     }
 
     PipeController pipeController(fCanvas.get());
     SkGPipeWriter writer;
     SkCanvas* pipeCanvas = writer.startRecording(&pipeController);
     pipeCanvas->drawPicture(fPicture);
     writer.endRecording();
     fCanvas->flush();
     if (out) {
@@ skipping 18 matching lines @@
 
 void SimplePictureRenderer::init(const SkPicture* picture, const SkString* writePath,
                                  const SkString* mismatchPath, const SkString* inputFilename,
                                  bool useChecksumBasedFilenames, bool useMultiPictureDraw) {
     INHERITED::init(picture, writePath, mismatchPath, inputFilename,
                     useChecksumBasedFilenames, useMultiPictureDraw);
     this->buildBBoxHierarchy();
 }
 
 bool SimplePictureRenderer::render(SkBitmap** out) {
-    SkASSERT(fCanvas.get() != NULL);
+    SkASSERT(fCanvas.get() != nullptr);
     SkASSERT(fPicture);
-    if (NULL == fCanvas.get() || NULL == fPicture) {
+    if (nullptr == fCanvas.get() || nullptr == fPicture) {
         return false;
     }
 
     if (fUseMultiPictureDraw) {
         SkMultiPictureDraw mpd;
 
         mpd.add(fCanvas, fPicture);
 
         mpd.draw();
     } else {
@@ skipping 34 matching lines @@
     , fTileMinPowerOf2Width(0)
     , fCurrentTileOffset(-1)
     , fTilesX(0)
     , fTilesY(0) { }
 
 void TiledPictureRenderer::init(const SkPicture* pict, const SkString* writePath,
                                 const SkString* mismatchPath, const SkString* inputFilename,
                                 bool useChecksumBasedFilenames, bool useMultiPictureDraw) {
     SkASSERT(pict);
     SkASSERT(0 == fTileRects.count());
-    if (NULL == pict || fTileRects.count() != 0) {
+    if (nullptr == pict || fTileRects.count() != 0) {
         return;
     }
 
     // Do not call INHERITED::init(), which would create a (potentially large) canvas which is not
     // used by bench_pictures.
     fPicture.reset(pict)->ref();
     this->CopyString(&fWritePath, writePath);
     this->CopyString(&fMismatchPath, mismatchPath);
     this->CopyString(&fInputFilename, inputFilename);
     fUseChecksumBasedFilenames = useChecksumBasedFilenames;
@@ skipping 36 matching lines @@
                 // Only count tiles in the X direction on the first pass.
                 fTilesX++;
             }
             *fTileRects.append() = SkIRect::MakeXYWH(tile_x_start, tile_y_start,
                                                      fTileWidth, fTileHeight);
         }
     }
 }
 
 bool TiledPictureRenderer::tileDimensions(int &x, int &y) {
-    if (fTileRects.count() == 0 || NULL == fPicture) {
+    if (fTileRects.count() == 0 || nullptr == fPicture) {
         return false;
     }
     x = fTilesX;
     y = fTilesY;
     return true;
 }
 
 // The goal of the powers of two tiles is to minimize the amount of wasted tile
 // space in the width-wise direction and then minimize the number of tiles. The
 // constraints are that every tile must have a pixel width that is a power of
@@ skipping 116 matching lines @@
             bitmapCopyAtOffset(*tempBM, *out, tileRect.left(), tileRect.top());
         } else {
             success = false;
         }
     }
 
     return success;
 }
 
 bool TiledPictureRenderer::render(SkBitmap** out) {
-    SkASSERT(fPicture != NULL);
-    if (NULL == fPicture) {
+    SkASSERT(fPicture != nullptr);
+    if (nullptr == fPicture) {
         return false;
     }
 
     SkBitmap bitmap;
     if (out) {
         *out = new SkBitmap;
         setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()),
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         setup_bitmap(&bitmap, fTileWidth, fTileHeight);
     }
@@ skipping 110 matching lines @@
 SkString PlaybackCreationRenderer::getConfigNameInternal() {
     return SkString("playback_creation");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // SkPicture variants for each BBoxHierarchy type
 
 SkBBHFactory* PictureRenderer::getFactory() {
     switch (fBBoxHierarchyType) {
         case kNone_BBoxHierarchyType:
-            return NULL;
+            return nullptr;
         case kRTree_BBoxHierarchyType:
             return new SkRTreeFactory;
     }
     SkASSERT(0); // invalid bbhType
-    return NULL;
+    return nullptr;
 }
 
 } // namespace sk_tools