Style Change: NULL->nullptr

tests/CodexTest.cpp

 /*
  * Copyright 2015 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 "SkCodec.h"
@@ skipping 28 matching lines @@
 static void compare_to_good_digest(skiatest::Reporter* r, const SkMD5::Digest& goodDigest,
                            const SkBitmap& bm) {
     SkMD5::Digest digest;
     md5(bm, &digest);
     REPORTER_ASSERT(r, digest == goodDigest);
 }
 
 /**
  *  Test decoding an SkCodec to a particular SkImageInfo.
  *
- *  Calling getPixels(info) should return expectedResult, and if goodDigest is non NULL,
+ *  Calling getPixels(info) should return expectedResult, and if goodDigest is non nullptr,
  *  the resulting decode should match.
  */
 static void test_info(skiatest::Reporter* r, SkCodec* codec, const SkImageInfo& info,
                       SkCodec::Result expectedResult, const SkMD5::Digest* goodDigest) {
     SkBitmap bm;
     bm.allocPixels(info);
     SkAutoLockPixels autoLockPixels(bm);
 
     SkCodec::Result result = codec->getPixels(info, bm.getPixels(), bm.rowBytes());
     REPORTER_ASSERT(r, result == expectedResult);
@@ skipping 37 matching lines @@
     // on the color type (ex: building a color table for kIndex8).  DM is where we test
     // decodes to all possible destination color types.
     SkImageInfo info = codec->getInfo().makeColorType(kN32_SkColorType);
     REPORTER_ASSERT(r, info.dimensions() == size);
 
     {
         // Test decoding to 565
         SkImageInfo info565 = info.makeColorType(kRGB_565_SkColorType);
         SkCodec::Result expected = (supports565 && info.alphaType() == kOpaque_SkAlphaType) ?
                 SkCodec::kSuccess : SkCodec::kInvalidConversion;
-        test_info(r, codec, info565, expected, NULL);
+        test_info(r, codec, info565, expected, nullptr);
     }
 
     SkBitmap bm;
     bm.allocPixels(info);
     SkAutoLockPixels autoLockPixels(bm);
     SkCodec::Result result =
-        codec->getPixels(info, bm.getPixels(), bm.rowBytes(), NULL, NULL, NULL);
+        codec->getPixels(info, bm.getPixels(), bm.rowBytes(), nullptr, nullptr, nullptr);
     REPORTER_ASSERT(r, result == SkCodec::kSuccess);
 
     SkMD5::Digest digest;
     md5(bm, &digest);
 
     // verify that re-decoding gives the same result.
     test_info(r, codec, info, SkCodec::kSuccess, &digest);
 
     {
         // Check alpha type conversions
         if (info.alphaType() == kOpaque_SkAlphaType) {
             test_info(r, codec, info.makeAlphaType(kUnpremul_SkAlphaType),
-                      SkCodec::kInvalidConversion, NULL);
+                      SkCodec::kInvalidConversion, nullptr);
             test_info(r, codec, info.makeAlphaType(kPremul_SkAlphaType),
-                      SkCodec::kInvalidConversion, NULL);
+                      SkCodec::kInvalidConversion, nullptr);
         } else {
             // Decoding to opaque should fail
             test_info(r, codec, info.makeAlphaType(kOpaque_SkAlphaType),
-                      SkCodec::kInvalidConversion, NULL);
+                      SkCodec::kInvalidConversion, nullptr);
             SkAlphaType otherAt = info.alphaType();
             if (kPremul_SkAlphaType == otherAt) {
                 otherAt = kUnpremul_SkAlphaType;
             } else {
                 otherAt = kPremul_SkAlphaType;
             }
             // The other non-opaque alpha type should always succeed, but not match.
-            test_info(r, codec, info.makeAlphaType(otherAt), SkCodec::kSuccess, NULL);
+            test_info(r, codec, info.makeAlphaType(otherAt), SkCodec::kSuccess, nullptr);
         }
     }
 
     // Scanline decoding follows.
 
     stream.reset(resource(path));
     SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(
             SkScanlineDecoder::NewFromStream(stream.detach()));
     if (supportsScanlineDecoding) {
         bm.eraseColor(SK_ColorYELLOW);
@@ skipping 26 matching lines @@
     for (int i = 0; i < 5; i++) {
         subset = generate_random_subset(&rand, size.width(), size.height());
         SkASSERT(!subset.isEmpty());
         const bool supported = codec->getValidSubset(&subset);
         REPORTER_ASSERT(r, supported == supportsSubsetDecoding);
 
         SkImageInfo subsetInfo = info.makeWH(subset.width(), subset.height());
         SkBitmap bm;
         bm.allocPixels(subsetInfo);
         const SkCodec::Result result = codec->getPixels(bm.info(), bm.getPixels(), bm.rowBytes(),
-                                                        &opts, NULL, NULL);
+                                                        &opts, nullptr, nullptr);
 
         if (supportsSubsetDecoding) {
             REPORTER_ASSERT(r, result == SkCodec::kSuccess);
             // Webp is the only codec that supports subsets, and it will have modified the subset
             // to have even left/top.
             REPORTER_ASSERT(r, SkIsAlign2(subset.fLeft) && SkIsAlign2(subset.fTop));
         } else {
             // No subsets will work.
             REPORTER_ASSERT(r, result == SkCodec::kUnimplemented);
         }
@@ skipping 96 matching lines @@
         SkImageInfo scaledInfo = codec->getInfo()
                 .makeWH(scaledDims.width(), scaledDims.height())
                 .makeColorType(kN32_SkColorType);
 
         // Set up for the decode
         size_t rowBytes = scaledDims.width() * sizeof(SkPMColor);
         size_t totalBytes = scaledInfo.getSafeSize(rowBytes);
         SkAutoTMalloc<SkPMColor> pixels(totalBytes);
 
         SkCodec::Result result =
-                codec->getPixels(scaledInfo, pixels.get(), rowBytes, NULL, NULL, NULL);
+                codec->getPixels(scaledInfo, pixels.get(), rowBytes, nullptr, nullptr, nullptr);
         REPORTER_ASSERT(r, SkCodec::kSuccess == result);
     }
 }
 
 // Ensure that onGetScaledDimensions returns valid image dimensions to use for decodes
 DEF_TEST(Codec_Dimensions, r) {
     // JPG
     test_dimensions(r, "CMYK.jpg");
     test_dimensions(r, "color_wheel.jpg");
     test_dimensions(r, "grayscale.jpg");
@@ skipping 16 matching lines @@
 
 }
 
 static void test_invalid(skiatest::Reporter* r, const char path[]) {
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.detach()));
-    REPORTER_ASSERT(r, NULL == codec);
+    REPORTER_ASSERT(r, nullptr == codec);
 }
 
 DEF_TEST(Codec_Empty, r) {
     // Test images that should not be able to create a codec
     test_invalid(r, "empty_images/zero-dims.gif");
     test_invalid(r, "empty_images/zero-embedded.ico");
     test_invalid(r, "empty_images/zero-width.bmp");
     test_invalid(r, "empty_images/zero-height.bmp");
     test_invalid(r, "empty_images/zero-width.jpg");
     test_invalid(r, "empty_images/zero-height.jpg");
@@ skipping 11 matching lines @@
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
     SkAutoTDelete<SkScanlineDecoder> decoder(SkScanlineDecoder::NewFromStream(
         stream.detach()));
     
     // This should return kSuccess because kIndex8 is supported.
     SkPMColor colorStorage[256];
     int colorCount;
     SkCodec::Result result = decoder->start(
-        decoder->getInfo().makeColorType(kIndex_8_SkColorType), NULL, colorStorage, &colorCount);
+        decoder->getInfo().makeColorType(kIndex_8_SkColorType), nullptr, colorStorage, &colorCount);
     REPORTER_ASSERT(r, SkCodec::kSuccess == result);
     // The rest of the test is uninteresting if kIndex8 is not supported
     if (SkCodec::kSuccess != result) {
         return;
     }
 
     // This should return kInvalidParameters because, in kIndex_8 mode, we must pass in a valid
     // colorPtr and a valid colorCountPtr.
     result = decoder->start(
-        decoder->getInfo().makeColorType(kIndex_8_SkColorType), NULL, NULL, NULL);
+        decoder->getInfo().makeColorType(kIndex_8_SkColorType), nullptr, nullptr, nullptr);
     REPORTER_ASSERT(r, SkCodec::kInvalidParameters == result);
     result = decoder->start(
         decoder->getInfo().makeColorType(kIndex_8_SkColorType));
     REPORTER_ASSERT(r, SkCodec::kInvalidParameters == result);
 }
 
 DEF_TEST(Codec_Params, r) {
     test_invalid_parameters(r, "index8.png");
     test_invalid_parameters(r, "mandrill.wbmp");
 }