Style Change: NULL->nullptr

tests/GrPorterDuffTest.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 "SkXfermode.h"
 #include "Test.h"
 
@@ skipping 58 matching lines @@
     kCanTweakAlphaForCoverage_OptFlag = GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag
 };
 
 class GrPorterDuffTest {
 public:
     struct XPInfo {
         XPInfo(skiatest::Reporter* reporter, SkXfermode::Mode xfermode, const GrCaps& caps,
                const GrProcOptInfo& colorPOI, const GrProcOptInfo& covPOI) {
             SkAutoTUnref<GrXPFactory> xpf(GrPorterDuffXPFactory::Create(xfermode));
             SkAutoTUnref<GrXferProcessor> xp(
-                xpf->createXferProcessor(colorPOI, covPOI, false, NULL, caps));
+                xpf->createXferProcessor(colorPOI, covPOI, false, nullptr, caps));
             TEST_ASSERT(!xpf->willNeedDstTexture(caps, colorPOI, covPOI, false));
             xpf->getInvariantBlendedColor(colorPOI, &fBlendedColor);
-            fOptFlags = xp->getOptimizations(colorPOI, covPOI, false, NULL, caps);
+            fOptFlags = xp->getOptimizations(colorPOI, covPOI, false, nullptr, caps);
             GetXPOutputTypes(xp, &fPrimaryOutputType, &fSecondaryOutputType);
             xp->getBlendInfo(&fBlendInfo);
             TEST_ASSERT(!xp->willReadDstColor());
             TEST_ASSERT(xp->hasSecondaryOutput() == GrBlendCoeffRefsSrc2(fBlendInfo.fDstBlend));
         }
 
         GrXPFactory::InvariantBlendedColor fBlendedColor;
         int fOptFlags;
         int fPrimaryOutputType;
         int fSecondaryOutputType;
         GrXferProcessor::BlendInfo fBlendInfo;
     };
 
     static void GetXPOutputTypes(const GrXferProcessor* xp, int* outPrimary, int* outSecondary) {
         GrPorterDuffXPFactory::TestGetXPOutputTypes(xp, outPrimary, outSecondary);
     }
 };
 
 static void test_color_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
-    colorPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, false);
-    covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);
+    colorPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags, false);
+    covPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags, true);
 
     SkASSERT(!colorPOI.isOpaque());
     SkASSERT(!colorPOI.isSolidWhite());
     SkASSERT(!covPOI.isSolidWhite());
     SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
@@ skipping 169 matching lines @@
                 break;
             default:
                 ERRORF(reporter, "Invalid xfermode.");
                 break;
         }
     }
 }
 
 static void test_color_unknown_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
-    colorPOI.calcWithInitialValues(NULL, 0, GrColorPackRGBA(229, 0, 154, 0),
+    colorPOI.calcWithInitialValues(nullptr, 0, GrColorPackRGBA(229, 0, 154, 0),
                                    kR_GrColorComponentFlag | kB_GrColorComponentFlag, false);
-    covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
+    covPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
 
     SkASSERT(!colorPOI.isOpaque());
     SkASSERT(!colorPOI.isSolidWhite());
     SkASSERT(covPOI.isSolidWhite());
     SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
@@ skipping 180 matching lines @@
                 break;
             default:
                 ERRORF(reporter, "Invalid xfermode.");
                 break;
         }
     }
 }
 
 static void test_color_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
-    colorPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kA_GrColorComponentFlag, false);
-    covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);
+    colorPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255), kA_GrColorComponentFlag, false);
+    covPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags, true);
 
     SkASSERT(colorPOI.isOpaque());
     SkASSERT(!colorPOI.isSolidWhite());
     SkASSERT(!covPOI.isSolidWhite());
     SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
@@ skipping 175 matching lines @@
                 break;
             default:
                 ERRORF(reporter, "Invalid xfermode.");
                 break;
         }
     }
 }
 
 static void test_color_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
-    colorPOI.calcWithInitialValues(NULL, 0, GrColorPackRGBA(0, 82, 0, 255),
+    colorPOI.calcWithInitialValues(nullptr, 0, GrColorPackRGBA(0, 82, 0, 255),
                                    kG_GrColorComponentFlag | kA_GrColorComponentFlag, false);
-    covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
+    covPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
 
     SkASSERT(colorPOI.isOpaque());
     SkASSERT(!colorPOI.isSolidWhite());
     SkASSERT(covPOI.isSolidWhite());
     SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
@@ skipping 202 matching lines @@
         }
 
         const char* name() const override { return "Test LCD Text Batch"; }
         void initBatchTracker(const GrPipelineOptimizations&) override {}
         bool onCombineIfPossible(GrBatch*, const GrCaps&) override  { return false; }
         void onPrepareDraws(Target*) override {};
 
     } testLCDCoverageBatch;
 
     GrProcOptInfo colorPOI, covPOI;
-    colorPOI.calcColorWithBatch(&testLCDCoverageBatch, NULL, 0);
-    covPOI.calcCoverageWithBatch(&testLCDCoverageBatch, NULL, 0);
+    colorPOI.calcColorWithBatch(&testLCDCoverageBatch, nullptr, 0);
+    covPOI.calcCoverageWithBatch(&testLCDCoverageBatch, nullptr, 0);
 
     SkASSERT(kRGBA_GrColorComponentFlags == colorPOI.validFlags());
     SkASSERT(covPOI.isFourChannelOutput());
 
     SkAutoTUnref<GrXPFactory> xpf(GrPorterDuffXPFactory::Create(SkXfermode::kSrcOver_Mode));
     TEST_ASSERT(!xpf->willNeedDstTexture(caps, colorPOI, covPOI, false));
 
     SkAutoTUnref<GrXferProcessor> xp(
-        xpf->createXferProcessor(colorPOI, covPOI, false, NULL, caps));
+        xpf->createXferProcessor(colorPOI, covPOI, false, nullptr, caps));
     if (!xp) {
         ERRORF(reporter, "Failed to create an XP with LCD coverage.");
         return;
     }
 
     GrXPFactory::InvariantBlendedColor blendedColor;
     xpf->getInvariantBlendedColor(colorPOI, &blendedColor);
     TEST_ASSERT(blendedColor.fWillBlendWithDst);
     TEST_ASSERT(kNone_GrColorComponentFlags == blendedColor.fKnownColorFlags);
 
@@ skipping 38 matching lines @@
     };
     static const GrColorComponentFlags testColorFlags[] = {
         kNone_GrColorComponentFlags,
         kG_GrColorComponentFlag | kA_GrColorComponentFlag,
         kRGBA_GrColorComponentFlags
     };
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(testColors) == SK_ARRAY_COUNT(testColorFlags));
 
     for (size_t c = 0; c < SK_ARRAY_COUNT(testColors); c++) {
         GrProcOptInfo colorPOI;
-        colorPOI.calcWithInitialValues(NULL, 0, testColors[c], testColorFlags[c], false);
+        colorPOI.calcWithInitialValues(nullptr, 0, testColors[c], testColorFlags[c], false);
         for (int f = 0; f <= 1; f++) {
             GrProcOptInfo covPOI;
             if (!f) {
-                covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);
+                covPOI.calcWithInitialValues(nullptr, 0, 0, kNone_GrColorComponentFlags, true);
             } else {
-                covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255),
+                covPOI.calcWithInitialValues(nullptr, 0, GrColorPackA4(255),
                                              kRGBA_GrColorComponentFlags, true);
             }
             for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
                 SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
                 SkAutoTUnref<GrXPFactory> xpf(GrPorterDuffXPFactory::Create(xfermode));
                 GrXferProcessor::DstTexture* dstTexture =
                     xpf->willNeedDstTexture(caps, colorPOI, covPOI, false) ? &fakeDstTexture : 0;
                 SkAutoTUnref<GrXferProcessor> xp(
                     xpf->createXferProcessor(colorPOI, covPOI, false, dstTexture, caps));
                 if (!xp) {
                     ERRORF(reporter, "Failed to create an XP without dual source blending.");
                     return;
                 }
                 TEST_ASSERT(!xp->hasSecondaryOutput());
                 xp->getOptimizations(colorPOI, covPOI, false, 0, caps);
                 TEST_ASSERT(!xp->hasSecondaryOutput());
             }
         }
     }
 }
 
 #endif