Style Change: NULL->nullptr

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "nanobench.h"
@@ skipping 123 matching lines @@
     bmp->setInfo(canvas->imageInfo());
     if (!canvas->readPixels(bmp, 0, 0)) {
         SkDebugf("Can't read canvas pixels.\n");
         return false;
     }
     return true;
 }
 
 #if SK_SUPPORT_GPU
 struct GPUTarget : public Target {
-    explicit GPUTarget(const Config& c) : Target(c), gl(NULL) { }
+    explicit GPUTarget(const Config& c) : Target(c), gl(nullptr) { }
     SkGLContext* gl;
 
     void setup() override {
         this->gl->makeCurrent();
         // Make sure we're done with whatever came before.
         SK_GL(*this->gl, Finish());
     }
     void endTiming() override {
         if (this->gl) {
             SK_GL(*this->gl, Flush());
@@ skipping 296 matching lines @@
 
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     if (is_cpu_config_allowed("hwui")) {
         Config config = { "hwui", Benchmark::kHWUI_Backend, kRGBA_8888_SkColorType,
                           kPremul_SkAlphaType, 0, kBogusGLContextType, false };
         configs->push(config);
     }
 #endif
 }
 
-// If bench is enabled for config, returns a Target* for it, otherwise NULL.
+// If bench is enabled for config, returns a Target* for it, otherwise nullptr.
 static Target* is_enabled(Benchmark* bench, const Config& config) {
     if (!bench->isSuitableFor(config.backend)) {
-        return NULL;
+        return nullptr;
     }
 
     SkImageInfo info = SkImageInfo::Make(bench->getSize().fX, bench->getSize().fY,
                                          config.color, config.alpha);
 
-    Target* target = NULL;
+    Target* target = nullptr;
 
     switch (config.backend) {
 #if SK_SUPPORT_GPU
     case Benchmark::kGPU_Backend:
         target = new GPUTarget(config);
         break;
 #endif
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     case Benchmark::kHWUI_Backend:
         target = new HWUITarget(config, bench);
         break;
 #endif
     default:
         target = new Target(config);
         break;
     }
 
     if (!target->init(info, bench)) {
         delete target;
-        return NULL;
+        return nullptr;
     }
     return target;
 }
 
 /*
  * Returns true if set up for a subset decode succeeds, false otherwise
  * If the set-up succeeds, the width and height parameters will be set
  */
 static bool valid_subset_bench(const SkString& path, SkColorType colorType, bool useCodec,
         int* width, int* height) {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
     SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(encoded));
 
     // Check that we can create a codec or image decoder.
     if (useCodec) {
         SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.detach()));
-        if (NULL == codec) {
+        if (nullptr == codec) {
             SkDebugf("Could not create codec for %s.  Skipping bench.\n", path.c_str());
             return false;
         }
 
         // These will be initialized by SkCodec if the color type is kIndex8 and
         // unused otherwise.
         SkPMColor colors[256];
         int colorCount;
         const SkImageInfo info = codec->getInfo().makeColorType(colorType);
         SkAutoTDeleteArray<uint8_t> row(new uint8_t[info.minRowBytes()]);
         SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(SkScanlineDecoder::NewFromData(encoded));
-        if (NULL == scanlineDecoder || scanlineDecoder->start(info, NULL,
+        if (nullptr == scanlineDecoder || scanlineDecoder->start(info, nullptr,
                 colors, &colorCount) != SkCodec::kSuccess)
         {
             SkDebugf("Could not create scanline decoder for %s with color type %s.  "
                     "Skipping bench.\n", path.c_str(), get_color_name(colorType));
             return false;
         }
         *width = info.width();
         *height = info.height();
     } else {
         SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream));
-        if (NULL == decoder) {
+        if (nullptr == decoder) {
             SkDebugf("Could not create decoder for %s.  Skipping bench.\n", path.c_str());
             return false;
         }
         //FIXME: See skbug.com/3921
         if (kIndex_8_SkColorType == colorType || kGray_8_SkColorType == colorType) {
             SkDebugf("Cannot use image subset decoder for %s with color type %s.  "
                     "Skipping bench.\n", path.c_str(), get_color_name(colorType));
             return false;
         }
         if (!decoder->buildTileIndex(stream.detach(), width, height)) {
@@ skipping 100 matching lines @@
     }
 
     static bool ReadPicture(const char* path, SkAutoTUnref<SkPicture>* pic) {
         // Not strictly necessary, as it will be checked again later,
         // but helps to avoid a lot of pointless work if we're going to skip it.
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path)) {
             return false;
         }
 
         SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(path));
-        if (stream.get() == NULL) {
+        if (stream.get() == nullptr) {
             SkDebugf("Could not read %s.\n", path);
             return false;
         }
 
         pic->reset(SkPicture::CreateFromStream(stream.get()));
-        if (pic->get() == NULL) {
+        if (pic->get() == nullptr) {
             SkDebugf("Could not read %s as an SkPicture.\n", path);
             return false;
         }
         return true;
     }
 
     Benchmark* next() {
         if (fBenches) {
-            Benchmark* bench = fBenches->factory()(NULL);
+            Benchmark* bench = fBenches->factory()(nullptr);
             fBenches = fBenches->next();
             fSourceType = "bench";
             fBenchType  = "micro";
             return bench;
         }
 
         while (fGMs) {
-            SkAutoTDelete<skiagm::GM> gm(fGMs->factory()(NULL));
+            SkAutoTDelete<skiagm::GM> gm(fGMs->factory()(nullptr));
             fGMs = fGMs->next();
             if (gm->runAsBench()) {
                 fSourceType = "gm";
                 fBenchType  = "micro";
                 return new GMBench(gm.detach());
             }
         }
 
         // First add all .skps as RecordingBenches.
         while (fCurrentRecording < fSKPs.count()) {
@@ skipping 91 matching lines @@
                 }
 
                 const size_t rowBytes = info.minRowBytes();
                 SkAutoMalloc storage(info.getSafeSize(rowBytes));
 
                 // Used if fCurrentColorType is kIndex_8_SkColorType
                 int colorCount = 256;
                 SkPMColor colors[256];
 
                 const SkCodec::Result result = codec->getPixels(
-                        info, storage.get(), rowBytes, NULL, colors,
+                        info, storage.get(), rowBytes, nullptr, colors,
                         &colorCount);
                 switch (result) {
                     case SkCodec::kSuccess:
                     case SkCodec::kIncompleteInput:
                         return new CodecBench(SkOSPath::Basename(path.c_str()),
                                 encoded, colorType);
                     case SkCodec::kInvalidConversion:
                         // This is okay. Not all conversions are valid.
                         break;
                     default:
@@ skipping 67 matching lines @@
                     fCurrentSubsetType = 0;
                     fCurrentColorType++;
                 }
                 fCurrentColorType = 0;
                 fCurrentSubsetImage++;
             }
             fCurrentSubsetImage = 0;
             fUseCodec++;
         }
 
-        return NULL;
+        return nullptr;
     }
 
     void fillCurrentOptions(ResultsWriter* log) const {
         log->configOption("source_type", fSourceType);
         log->configOption("bench_type",  fBenchType);
         if (0 == strcmp(fSourceType, "skp")) {
             log->configOption("clip",
                     SkStringPrintf("%d %d %d %d", fClip.fLeft, fClip.fTop,
                                                   fClip.fRight, fClip.fBottom).c_str());
             log->configOption("scale", SkStringPrintf("%.2g", fScales[fCurrentScale]).c_str());
@@ skipping 84 matching lines @@
 
     if (kAutoTuneLoops != FLAGS_loops) {
         FLAGS_samples     = 1;
         FLAGS_gpuFrameLag = 0;
     }
 
     if (!FLAGS_writePath.isEmpty()) {
         SkDebugf("Writing files to %s.\n", FLAGS_writePath[0]);
         if (!sk_mkdir(FLAGS_writePath[0])) {
             SkDebugf("Could not create %s. Files won't be written.\n", FLAGS_writePath[0]);
-            FLAGS_writePath.set(0, NULL);
+            FLAGS_writePath.set(0, nullptr);
         }
     }
 
     SkAutoTDelete<ResultsWriter> log(new ResultsWriter);
     if (!FLAGS_outResultsFile.isEmpty()) {
         log.reset(new NanoJSONResultsWriter(FLAGS_outResultsFile[0]));
     }
 
     if (1 == FLAGS_properties.count() % 2) {
         SkDebugf("ERROR: --properties must be passed with an even number of arguments.\n");
@@ skipping 41 matching lines @@
         if (!configs.isEmpty()) {
             log->bench(bench->getUniqueName(), bench->getSize().fX, bench->getSize().fY);
             bench->preDraw();
         }
         for (int i = 0; i < configs.count(); ++i) {
             Target* target = is_enabled(b, configs[i]);
             if (!target) {
                 continue;
             }
 
-            // During HWUI output this canvas may be NULL.
+            // During HWUI output this canvas may be nullptr.
             SkCanvas* canvas = target->getCanvas();
             const char* config = target->config.name;
 
             target->setup();
             bench->perCanvasPreDraw(canvas);
 
             int maxFrameLag;
             const int loops = target->needsFrameTiming(&maxFrameLag)
                 ? setup_gpu_bench(target, bench.get(), maxFrameLag)
                 : setup_cpu_bench(overhead, target, bench.get());
@@ skipping 92 matching lines @@
         }
     }
 
     log->bench("memory_usage", 0,0);
     log->config("meta");
     log->metric("max_rss_mb", sk_tools::getMaxResidentSetSizeMB());
 
 #if SK_SUPPORT_GPU
     // Make sure we clean up the global GrContextFactory here, otherwise we might race with the
     // SkEventTracer destructor
-    gGrFactory.reset(NULL);
+    gGrFactory.reset(nullptr);
 #endif
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif