Style Change: NULL->nullptr

tools/render_pictures_main.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 "LazyDecodeBitmap.h"
 #include "CopyTilesRenderer.h"
 #include "SkBitmap.h"
@@ skipping 94 matching lines @@
  *  Sets gInputFileName to name, minus any extension ".*"
  *  Sets gImageNo to 0, so images from file "X.skp" will
  *  look like "X_<gImageNo>.<suffix>", beginning with 0
  *  for each new skp.
  */
 static void reset_image_file_base_name(const SkString& name) {
     gImageNo = 0;
     // Remove ".skp"
     const char* cName = name.c_str();
     const char* dot = strrchr(cName, '.');
-    if (dot != NULL) {
+    if (dot != nullptr) {
         gInputFileName.set(cName, dot - cName);
     } else {
         gInputFileName.set(name);
     }
 }
 
 /**
  *  Write the raw encoded bitmap data to a file.
  */
 static bool write_image_to_file(const void* buffer, size_t size, SkBitmap* bitmap) {
@@ skipping 48 matching lines @@
         reset_image_file_base_name(inputFilename);
         proc = &write_image_to_file;
     } else {
         proc = &SkImageDecoder::DecodeMemory;
     }
 
     SkDebugf("deserializing... %s\n", inputPath.c_str());
 
     SkAutoTUnref<SkPicture> picture(SkPicture::CreateFromStream(&inputStream, proc));
 
-    if (NULL == picture) {
+    if (nullptr == picture) {
         SkDebugf("Could not read an SkPicture from %s\n", inputPath.c_str());
         return false;
     }
 
     while (FLAGS_bench_record) {
         SkPictureRecorder recorder;
         picture->playback(recorder.beginRecording(picture->cullRect().width(), 
                                                   picture->cullRect().height(), 
-                                                  NULL, 0));
+                                                  nullptr, 0));
         SkAutoTUnref<SkPicture> other(recorder.endRecording());
     }
 
     SkDebugf("drawing... [%f %f %f %f] %s\n", 
              picture->cullRect().fLeft, picture->cullRect().fTop,
              picture->cullRect().fRight, picture->cullRect().fBottom,
              inputPath.c_str());
 
     renderer.init(picture, &writePathString, &mismatchPathString, &inputFilename,
                   FLAGS_writeChecksumBasedFilenames, FLAGS_mpd);
@@ skipping 17 matching lines @@
 }
 
 static int MaxByteDiff(uint32_t v1, uint32_t v2) {
     return SkMax32(SkMax32(SkTAbs(getByte(v1, 0) - getByte(v2, 0)), SkTAbs(getByte(v1, 1) - getByte(v2, 1))),
                    SkMax32(SkTAbs(getByte(v1, 2) - getByte(v2, 2)), SkTAbs(getByte(v1, 3) - getByte(v2, 3))));
 }
 
 class AutoRestoreBbhType {
 public:
     AutoRestoreBbhType() {
-        fRenderer = NULL;
+        fRenderer = nullptr;
         fSavedBbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
     }
 
     void set(sk_tools::PictureRenderer* renderer,
              sk_tools::PictureRenderer::BBoxHierarchyType bbhType) {
         fRenderer = renderer;
         fSavedBbhType = renderer->getBBoxHierarchyType();
         renderer->setBBoxHierarchyType(bbhType);
     }
 
     ~AutoRestoreBbhType() {
         if (fRenderer) {
             fRenderer->setBBoxHierarchyType(fSavedBbhType);
         }
     }
 
 private:
     sk_tools::PictureRenderer* fRenderer;
     sk_tools::PictureRenderer::BBoxHierarchyType fSavedBbhType;
 };
 
 /**
  * Render the SKP file(s) within inputPath.
  *
  * @param inputPath path to an individual SKP file, or a directory of SKP files
- * @param writePath if not NULL, write all image(s) generated into this directory
- * @param mismatchPath if not NULL, write any image(s) not matching expectations into this directory
+ * @param writePath if not nullptr, write all image(s) generated into this directory
+ * @param mismatchPath if not nullptr, write any image(s) not matching expectations into this directory
  * @param renderer PictureRenderer to use to render the SKPs
- * @param jsonSummaryPtr if not NULL, add the image(s) generated to this summary
+ * @param jsonSummaryPtr if not nullptr, add the image(s) generated to this summary
  */
 static bool render_picture(const SkString& inputPath, const SkString* writePath,
                            const SkString* mismatchPath, sk_tools::PictureRenderer& renderer,
                            sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
     int diffs[256] = {0};
-    SkBitmap* bitmap = NULL;
+    SkBitmap* bitmap = nullptr;
     renderer.setJsonSummaryPtr(jsonSummaryPtr);
     bool success = render_picture_internal(inputPath,
-        FLAGS_writeWholeImage ? NULL : writePath,
-        FLAGS_writeWholeImage ? NULL : mismatchPath,
+        FLAGS_writeWholeImage ? nullptr : writePath,
+        FLAGS_writeWholeImage ? nullptr : mismatchPath,
         renderer,
-        FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : NULL);
+        FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : nullptr);
 
-    if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == NULL)) {
+    if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == nullptr)) {
         SkDebugf("Failed to draw the picture.\n");
         delete bitmap;
         return false;
     }
 
     if (FLAGS_validate) {
-        SkBitmap* referenceBitmap = NULL;
+        SkBitmap* referenceBitmap = nullptr;
         sk_tools::PictureRenderer* referenceRenderer;
         // If the renderer uses a BBoxHierarchy, then the reference renderer
         // will be the same renderer, without the bbh.
         AutoRestoreBbhType arbbh;
         if (sk_tools::PictureRenderer::kNone_BBoxHierarchyType !=
             renderer.getBBoxHierarchyType()) {
             referenceRenderer = &renderer;
             referenceRenderer->ref();  // to match auto unref below
             arbbh.set(referenceRenderer, sk_tools::PictureRenderer::kNone_BBoxHierarchyType);
         } else {
 #if SK_SUPPORT_GPU
             referenceRenderer = new sk_tools::SimplePictureRenderer(renderer.getGrContextOptions());
 #else
             referenceRenderer = new sk_tools::SimplePictureRenderer;
 #endif
         }
         SkAutoTUnref<sk_tools::PictureRenderer> aurReferenceRenderer(referenceRenderer);
 
-        success = render_picture_internal(inputPath, NULL, NULL, *referenceRenderer,
+        success = render_picture_internal(inputPath, nullptr, nullptr, *referenceRenderer,
                                           &referenceBitmap);
 
-        if (!success || NULL == referenceBitmap || NULL == referenceBitmap->getPixels()) {
+        if (!success || nullptr == referenceBitmap || nullptr == referenceBitmap->getPixels()) {
             SkDebugf("Failed to draw the reference picture.\n");
             delete bitmap;
             delete referenceBitmap;
             return false;
         }
 
         if (success && (bitmap->width() != referenceBitmap->width())) {
             SkDebugf("Expected image width: %i, actual image width %i.\n",
                      referenceBitmap->width(), bitmap->width());
             delete bitmap;
@@ skipping 42 matching lines @@
         SkString inputFilename = SkOSPath::Basename(inputPath.c_str());
         SkString outputFilename(inputFilename);
         sk_tools::replace_char(&outputFilename, '.', '_');
         outputFilename.append(".png");
 
         if (jsonSummaryPtr) {
             sk_tools::ImageDigest imageDigest(*bitmap);
             jsonSummaryPtr->add(inputFilename.c_str(), outputFilename.c_str(), imageDigest);
             if ((mismatchPath) && !mismatchPath->isEmpty() &&
                 !jsonSummaryPtr->getExpectation(inputFilename.c_str()).matches(imageDigest)) {
-                success &= sk_tools::write_bitmap_to_disk(*bitmap, *mismatchPath, NULL,
+                success &= sk_tools::write_bitmap_to_disk(*bitmap, *mismatchPath, nullptr,
                                                           outputFilename);
             }
         }
 
         if ((writePath) && !writePath->isEmpty()) {
-            success &= sk_tools::write_bitmap_to_disk(*bitmap, *writePath, NULL, outputFilename);
+            success &= sk_tools::write_bitmap_to_disk(*bitmap, *writePath, nullptr, outputFilename);
         }
     }
     delete bitmap;
 
     return success;
 }
 
 
 static int process_input(const char* input, const SkString* writePath,
                          const SkString* mismatchPath, sk_tools::PictureRenderer& renderer,
@@ skipping 53 matching lines @@
         }
     }
 
     SkString errorString;
     SkAutoTUnref<sk_tools::PictureRenderer> renderer(parseRenderer(errorString,
                                                                    kRender_PictureTool));
     if (errorString.size() > 0) {
         SkDebugf("%s\n", errorString.c_str());
     }
 
-    if (renderer.get() == NULL) {
+    if (renderer.get() == nullptr) {
         exit(-1);
     }
 
     SkAutoGraphics ag;
 
     SkString writePath;
     if (FLAGS_writePath.count() == 1) {
         writePath.set(FLAGS_writePath[0]);
     }
     SkString mismatchPath;
     if (FLAGS_mismatchPath.count() == 1) {
         mismatchPath.set(FLAGS_mismatchPath[0]);
     }
     sk_tools::ImageResultsAndExpectations jsonSummary;
-    sk_tools::ImageResultsAndExpectations* jsonSummaryPtr = NULL;
+    sk_tools::ImageResultsAndExpectations* jsonSummaryPtr = nullptr;
     if (FLAGS_writeJsonSummaryPath.count() == 1) {
         jsonSummaryPtr = &jsonSummary;
         if (FLAGS_readJsonSummaryPath.count() == 1) {
             SkASSERT(jsonSummary.readExpectationsFile(FLAGS_readJsonSummaryPath[0]));
         }
     }
 
     int failures = 0;
     for (int i = 0; i < FLAGS_readPath.count(); i ++) {
         failures += process_input(FLAGS_readPath[i], &writePath, &mismatchPath, *renderer.get(),
@@ skipping 30 matching lines @@
         jsonSummary.writeToFile(FLAGS_writeJsonSummaryPath[0]);
     }
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif