Style Change: NULL->nullptr

tests/ImageDecodingTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Resources.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 69 matching lines @@
     SkBitmap bm8888Unpremul;
 
     SkFILEStream stream(filename.c_str());
 
     SkImageDecoder::Format format = SkImageDecoder::GetStreamFormat(&stream);
     if (skip_image_format(format)) {
         return;
     }
 
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream));
-    if (NULL == decoder.get()) {
+    if (nullptr == decoder.get()) {
         SkDebugf("couldn't decode %s\n", filename.c_str());
         return;
     }
 
     bool success = decoder->decode(&stream, &bm8888, kN32_SkColorType,
                                    SkImageDecoder::kDecodePixels_Mode) != SkImageDecoder::kFailure;
     if (!success) {
         return;
     }
 
@@ skipping 68 matching lines @@
 }
 
 #if defined(SK_BUILD_FOR_ANDROID) || defined(SK_BUILD_FOR_UNIX)
 // Test that the alpha type is what we expect.
 static void test_alphaType(skiatest::Reporter* reporter, const SkString& filename,
                            bool requireUnpremul) {
     SkBitmap bm;
     SkFILEStream stream(filename.c_str());
 
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream));
-    if (NULL == decoder.get()) {
+    if (nullptr == decoder.get()) {
         return;
     }
 
     decoder->setRequireUnpremultipliedColors(requireUnpremul);
 
     // Decode just the bounds. This should always succeed.
     bool success = decoder->decode(&stream, &bm, kN32_SkColorType,
                                    SkImageDecoder::kDecodeBounds_Mode);
     REPORTER_ASSERT(reporter, success);
     if (!success) {
@@ skipping 84 matching lines @@
 
         if (!stream.isValid()) {
             SkDebugf("file %s missing from resource directoy %s\n",
                      basename.c_str(), resourcePath.c_str());
             continue;
         }
 
         // This should never fail since we know the images we're decoding.
         SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream));
         REPORTER_ASSERT(reporter, decoder.get());
-        if (NULL == decoder.get()) {
+        if (nullptr == decoder.get()) {
             continue;
         }
 
         // Test unpremultiplied. We know what color this should result in.
         decoder->setRequireUnpremultipliedColors(true);
         bool success = decoder->decode(&stream, &bm, kN32_SkColorType,
                                        SkImageDecoder::kDecodePixels_Mode);
         REPORTER_ASSERT(reporter, success);
         if (!success) {
             continue;
@@ skipping 122 matching lines @@
         REPORTER_ASSERT(reporter, !error);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // example of how Android will do this inside their BitmapFactory
 static SkPixelRef* install_pixel_ref(SkBitmap* bitmap,
                                      SkStreamRewindable* stream,
                                      int sampleSize, bool ditherImage) {
-    SkASSERT(bitmap != NULL);
-    SkASSERT(stream != NULL);
+    SkASSERT(bitmap != nullptr);
+    SkASSERT(stream != nullptr);
     SkASSERT(stream->rewind());
     SkColorType colorType = bitmap->colorType();
     SkDecodingImageGenerator::Options opts(sampleSize, ditherImage, colorType);
     if (SkInstallDiscardablePixelRef(
                 SkDecodingImageGenerator::Create(stream, opts), bitmap)) {
         return bitmap->pixelRef();
     }
-    return NULL;
+    return nullptr;
 }
 /**
  *  A test for the SkDecodingImageGenerator::Create and
  *  SkInstallDiscardablePixelRef functions.
  */
 DEF_TEST(ImprovedBitmapFactory, reporter) {
     SkString pngFilename = GetResourcePath("randPixels.png");
     SkAutoTDelete<SkStreamRewindable> stream(SkStream::NewFromFile(pngFilename.c_str()));
     if (sk_exists(pngFilename.c_str())) {
         SkBitmap bm;
@@ skipping 61 matching lines @@
  */
 static void test_options(skiatest::Reporter* reporter,
                          const SkDecodingImageGenerator::Options& opts,
                          SkStreamRewindable* encodedStream,
                          SkData* encodedData,
                          bool useData,
                          const SkString& path) {
     SkBitmap bm;
     bool success = false;
     if (useData) {
-        if (NULL == encodedData) {
+        if (nullptr == encodedData) {
             return;
         }
         success = SkInstallDiscardablePixelRef(
             SkDecodingImageGenerator::Create(encodedData, opts), &bm);
     } else {
-        if (NULL == encodedStream) {
+        if (nullptr == encodedStream) {
             return;
         }
         success = SkInstallDiscardablePixelRef(
             SkDecodingImageGenerator::Create(encodedStream->duplicate(), opts), &bm);
     }
     if (!success) {
         if (opts.fUseRequestedColorType
             && (kARGB_4444_SkColorType == opts.fRequestedColorType)) {
             return;  // Ignore known conversion inabilities.
         }
@@ skipping 12 matching lines @@
                                              opts.fSampleSize));
     REPORTER_ASSERT(reporter, check_rounding(bm.width(), kExpectedWidth,
                                              opts.fSampleSize));
     // The ImageDecoder API doesn't guarantee that SampleSize does
     // anything at all, but the decoders that this test excercises all
     // produce an output size in the following range:
     //    (((sample_size * out_size) > (in_size - sample_size))
     //     && out_size <= SkNextPow2(((in_size - 1) / sample_size) + 1));
     #endif  // SK_BUILD_FOR_ANDROID || SK_BUILD_FOR_UNIX
     SkAutoLockPixels alp(bm);
-    if (bm.getPixels() == NULL) {
+    if (bm.getPixels() == nullptr) {
         ERRORF(reporter, "Pixel decode failed [sampleSize=%d dither=%s "
                "colorType=%s %s]", opts.fSampleSize, yn(opts.fDitherImage),
                options_colorType(opts), path.c_str());
         return;
     }
 
     SkColorType requestedColorType = opts.fRequestedColorType;
     REPORTER_ASSERT(reporter,
                     (!opts.fUseRequestedColorType)
                     || (bm.colorType() == requestedColorType));
@@ skipping 60 matching lines @@
     };
     const bool useDataList[] = {true, false};
 
     for (size_t fidx = 0; fidx < SK_ARRAY_COUNT(files); ++fidx) {
         SkString path = SkOSPath::Join(resourceDir.c_str(), files[fidx]);
         if (!sk_exists(path.c_str())) {
             continue;
         }
 
         SkAutoDataUnref encodedData(SkData::NewFromFileName(path.c_str()));
-        REPORTER_ASSERT(reporter, encodedData.get() != NULL);
+        REPORTER_ASSERT(reporter, encodedData.get() != nullptr);
         SkAutoTDelete<SkStreamRewindable> encodedStream(
             SkStream::NewFromFile(path.c_str()));
-        REPORTER_ASSERT(reporter, encodedStream.get() != NULL);
+        REPORTER_ASSERT(reporter, encodedStream.get() != nullptr);
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(scaleList); ++i) {
             for (size_t j = 0; j < SK_ARRAY_COUNT(ditherList); ++j) {
                 for (size_t m = 0; m < SK_ARRAY_COUNT(useDataList); ++m) {
                     for (size_t k = 0; k < SK_ARRAY_COUNT(colorList); ++k) {
                         SkDecodingImageGenerator::Options opts(scaleList[i],
                                                                ditherList[j],
                                                                colorList[k]);
                         test_options(reporter, opts, encodedStream, encodedData,
                                      useDataList[m], path);
@@ skipping 43 matching lines @@
 namespace {
 class SingleAllocator : public SkBitmap::Allocator {
 public:
     SingleAllocator(void* p, size_t s) : fPixels(p), fSize(s) { }
     ~SingleAllocator() {}
     // If the pixels in fPixels are big enough, use them.
     bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) override {
         SkASSERT(bm);
         if (bm->info().getSafeSize(bm->rowBytes()) <= fSize) {
             bm->setPixels(fPixels, ct);
-            fPixels = NULL;
+            fPixels = nullptr;
             fSize = 0;
             return true;
         }
-        return bm->tryAllocPixels(NULL, ct);
+        return bm->tryAllocPixels(nullptr, ct);
     }
-    bool ready() { return fPixels != NULL; }
+    bool ready() { return fPixels != nullptr; }
 private:
     void* fPixels;
     size_t fSize;
 };
 }  // namespace
 
 /*  This tests for a bug in libjpeg where INT32 is typedefed to long
     and memory can be written to outside of the array. */
 DEF_TEST(ImageDecoding_JpegOverwrite, r) {
     SkString resourceDir = GetResourcePath();
     SkString path = SkOSPath::Join(resourceDir.c_str(), "randPixels.jpg");
     SkAutoTDelete<SkStreamAsset> stream(
             SkStream::NewFromFile(path.c_str()));
     if (!stream.get()) {
         SkDebugf("\nPath '%s' missing.\n", path.c_str());
         return;
     }
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream));
-    if (NULL == decoder.get()) {
+    if (nullptr == decoder.get()) {
         ERRORF(r, "\nSkImageDecoder::Factory failed.\n");
         return;
     }
     SkAssertResult(stream->rewind());
 
     static const uint16_t sentinal = 0xBEEF;
     static const int pixelCount = 16;
     SkAutoTMalloc<uint16_t> pixels(pixelCount + 1);
     // pixels.get() should be 4-byte aligned.
     // This is necessary to reproduce the bug.
 
     pixels[pixelCount] = sentinal;  // This value should not be changed.
 
     SkAutoTUnref<SingleAllocator> allocator(
             new SingleAllocator((void*)pixels.get(), sizeof(uint16_t) * pixelCount));
     decoder->setAllocator(allocator);
     decoder->setSampleSize(2);
     SkBitmap bitmap;
     bool success = decoder->decode(stream, &bitmap, kRGB_565_SkColorType,
                                    SkImageDecoder::kDecodePixels_Mode) != SkImageDecoder::kFailure;
     REPORTER_ASSERT(r, success);
     REPORTER_ASSERT(r, !allocator->ready());  // Decoder used correct memory
     REPORTER_ASSERT(r, sentinal == pixels[pixelCount]);
 }