Style Change: NULL->nullptr

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCodec.h"
@@ skipping 23 matching lines @@
 static bool lazy_decode_bitmap(const void* src, size_t size, SkBitmap* dst) {
     SkAutoTUnref<SkData> encoded(SkData::NewWithCopy(src, size));
     return encoded && SkInstallDiscardablePixelRef(encoded, dst);
 }
 
 namespace DM {
 
 GMSrc::GMSrc(skiagm::GMRegistry::Factory factory) : fFactory(factory) {}
 
 Error GMSrc::draw(SkCanvas* canvas) const {
-    SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
+    SkAutoTDelete<skiagm::GM> gm(fFactory(nullptr));
     canvas->concat(gm->getInitialTransform());
     gm->draw(canvas);
     return "";
 }
 
 SkISize GMSrc::size() const {
-    SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
+    SkAutoTDelete<skiagm::GM> gm(fFactory(nullptr));
     return gm->getISize();
 }
 
 Name GMSrc::name() const {
-    SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
+    SkAutoTDelete<skiagm::GM> gm(fFactory(nullptr));
     return gm->getName();
 }
 
 void GMSrc::modifyGrContextOptions(GrContextOptions* options) const {
-    SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
+    SkAutoTDelete<skiagm::GM> gm(fFactory(nullptr));
     gm->modifyGrContextOptions(options);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType, float scale)
     : fPath(path)
     , fMode(mode)
     , fDstColorType(dstColorType)
     , fScale(scale)
 {}
 
 bool CodecSrc::veto(SinkFlags flags) const {
     // No need to test decoding to non-raster or indirect backend.
     // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
     // let the GPU handle it.
     return flags.type != SinkFlags::kRaster
         || flags.approach != SinkFlags::kDirect;
 }
 
 Error CodecSrc::draw(SkCanvas* canvas) const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     if (!encoded) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
     SkAutoTDelete<SkCodec> codec(SkScaledCodec::NewFromData(encoded));
-    if (NULL == codec.get()) {
+    if (nullptr == codec.get()) {
         // scaledCodec not supported, try normal codec
         codec.reset(SkCodec::NewFromData(encoded));
-        if (NULL == codec.get()) {
+        if (nullptr == codec.get()) {
             return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
         }
     }
 
     // Choose the color type to decode to
     SkImageInfo decodeInfo = codec->getInfo();
     SkColorType canvasColorType = canvas->imageInfo().colorType();
     switch (fDstColorType) {
         case kIndex8_Always_DstColorType:
             decodeInfo = codec->getInfo().makeColorType(kIndex_8_SkColorType);
@@ skipping 19 matching lines @@
     }
 
     // Visually inspecting very small output images is not necessary.  We will
     // cover these cases in unit testing.
     if ((size.width() <= 10 || size.height() <= 10) && 1.0f != fScale) {
         return Error::Nonfatal("Scaling very small images is uninteresting.");
     }
     decodeInfo = decodeInfo.makeWH(size.width(), size.height());
 
     // Construct a color table for the decode if necessary
-    SkAutoTUnref<SkColorTable> colorTable(NULL);
-    SkPMColor* colorPtr = NULL;
-    int* colorCountPtr = NULL;
+    SkAutoTUnref<SkColorTable> colorTable(nullptr);
+    SkPMColor* colorPtr = nullptr;
+    int* colorCountPtr = nullptr;
     int maxColors = 256;
     if (kIndex_8_SkColorType == decodeInfo.colorType()) {
         SkPMColor colors[256];
         colorTable.reset(new SkColorTable(colors, maxColors));
         colorPtr = const_cast<SkPMColor*>(colorTable->readColors());
         colorCountPtr = &maxColors;
     }
 
     // FIXME: Currently we cannot draw unpremultiplied sources.
     if (decodeInfo.alphaType() == kUnpremul_SkAlphaType) {
         decodeInfo = decodeInfo.makeAlphaType(kPremul_SkAlphaType);
     }
 
     SkBitmap bitmap;
-    if (!bitmap.tryAllocPixels(decodeInfo, NULL, colorTable.get())) {
+    if (!bitmap.tryAllocPixels(decodeInfo, nullptr, colorTable.get())) {
         return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
                               decodeInfo.width(), decodeInfo.height());
     }
 
     switch (fMode) {
         case kNormal_Mode: {
-            switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(), NULL,
+            switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(), nullptr,
                     colorPtr, colorCountPtr)) {
                 case SkCodec::kSuccess:
                     // We consider incomplete to be valid, since we should still decode what is
                     // available.
                 case SkCodec::kIncompleteInput:
                     break;
                 case SkCodec::kInvalidConversion:
                     return Error::Nonfatal("Incompatible colortype conversion");
                 default:
                     // Everything else is considered a failure.
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Mode: {
             SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(
                     SkScanlineDecoder::NewFromData(encoded));
-            if (NULL == scanlineDecoder || SkCodec::kSuccess !=
-                    scanlineDecoder->start(decodeInfo, NULL, colorPtr, colorCountPtr)) {
+            if (nullptr == scanlineDecoder || SkCodec::kSuccess !=
+                    scanlineDecoder->start(decodeInfo, nullptr, colorPtr, colorCountPtr)) {
                 return Error::Nonfatal("Cannot use scanline decoder for all images");
             }
 
             const SkCodec::Result result = scanlineDecoder->getScanlines(
                     bitmap.getAddr(0, 0), decodeInfo.height(), bitmap.rowBytes());
             switch (result) {
                 case SkCodec::kSuccess:
                 case SkCodec::kIncompleteInput:
                     break;
                 default:
@@ skipping 22 matching lines @@
             * subsets to cover entire image.
             * Add extraX and extraY to largestSubsetBm's width and height to adjust width
             * and height of end subsets.
             * subsetBm is extracted from largestSubsetBm.
             * subsetBm's size is determined based on the current subset and may be larger for end
             * subsets.
             */
             SkImageInfo largestSubsetDecodeInfo =
                     decodeInfo.makeWH(subsetWidth + extraX, subsetHeight + extraY);
             SkBitmap largestSubsetBm;
-            if (!largestSubsetBm.tryAllocPixels(largestSubsetDecodeInfo, NULL, colorTable.get())) {
+            if (!largestSubsetBm.tryAllocPixels(largestSubsetDecodeInfo, nullptr, colorTable.get())) {
                 return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
                         largestSubsetDecodeInfo.width(), largestSubsetDecodeInfo.height());
             }
             const size_t rowBytes = decodeInfo.minRowBytes();
             char* buffer = new char[largestSubsetDecodeInfo.height() * rowBytes];
             SkAutoTDeleteArray<char> lineDeleter(buffer);
             for (int col = 0; col < divisor; col++) {
                 //currentSubsetWidth may be larger than subsetWidth for rightmost subsets
                 const int currentSubsetWidth = (col + 1 == divisor) ?
                         subsetWidth + extraX : subsetWidth;
                 const int x = col * subsetWidth;
                 for (int row = 0; row < divisor; row++) {
                     //currentSubsetHeight may be larger than subsetHeight for bottom subsets
                     const int currentSubsetHeight = (row + 1 == divisor) ?
                             subsetHeight + extraY : subsetHeight;
                     const int y = row * subsetHeight;
                     //create scanline decoder for each subset
                     SkAutoTDelete<SkScanlineDecoder> subsetScanlineDecoder(
                             SkScanlineDecoder::NewFromData(encoded));
-                    if (NULL == subsetScanlineDecoder || SkCodec::kSuccess !=
+                    if (nullptr == subsetScanlineDecoder || SkCodec::kSuccess !=
                             subsetScanlineDecoder->start(
-                            decodeInfo, NULL, colorPtr, colorCountPtr))
+                            decodeInfo, nullptr, colorPtr, colorCountPtr))
                     {
                         if (x == 0 && y == 0) {
                             //first try, image may not be compatible
                             return Error::Nonfatal("Cannot use scanline decoder for all images");
                         } else {
-                            return "Error scanline decoder is NULL";
+                            return "Error scanline decoder is nullptr";
                         }
                     }
                     //skip to first line of subset
                     const SkCodec::Result skipResult =
                             subsetScanlineDecoder->skipScanlines(y);
                     switch (skipResult) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
@@ skipping 41 matching lines @@
         }
         case kStripe_Mode: {
             const int height = decodeInfo.height();
             // This value is chosen arbitrarily.  We exercise more cases by choosing a value that
             // does not align with image blocks.
             const int stripeHeight = 37;
             const int numStripes = (height + stripeHeight - 1) / stripeHeight;
 
             // Decode odd stripes
             SkAutoTDelete<SkScanlineDecoder> decoder(SkScanlineDecoder::NewFromData(encoded));
-            if (NULL == decoder || SkCodec::kSuccess !=
-                    decoder->start(decodeInfo, NULL, colorPtr, colorCountPtr)) {
+            if (nullptr == decoder || SkCodec::kSuccess !=
+                    decoder->start(decodeInfo, nullptr, colorPtr, colorCountPtr)) {
                 return Error::Nonfatal("Cannot use scanline decoder for all images");
             }
             for (int i = 0; i < numStripes; i += 2) {
                 // Skip a stripe
                 const int linesToSkip = SkTMin(stripeHeight, height - i * stripeHeight);
                 SkCodec::Result result = decoder->skipScanlines(linesToSkip);
                 switch (result) {
                     case SkCodec::kSuccess:
                     case SkCodec::kIncompleteInput:
                         break;
@@ skipping 11 matching lines @@
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("Cannot get scanlines for %s.", fPath.c_str());
                     }
                 }
             }
 
             // Decode even stripes
-            const SkCodec::Result startResult = decoder->start(decodeInfo, NULL, colorPtr,
+            const SkCodec::Result startResult = decoder->start(decodeInfo, nullptr, colorPtr,
                                                                colorCountPtr);
             if (SkCodec::kSuccess != startResult) {
                 return "Failed to restart scanline decoder with same parameters.";
             }
             for (int i = 0; i < numStripes; i += 2) {
                 // Read a stripe
                 const int startY = i * stripeHeight;
                 const int linesToRead = SkTMin(stripeHeight, height - startY);
                 SkCodec::Result result = decoder->getScanlines(bitmap.getAddr(0, startY),
                         linesToRead, bitmap.rowBytes());
@@ skipping 53 matching lines @@
                     const int preScaleW = SkTMin(w, W - x);
                     const int preScaleH = SkTMin(h, H - y);
                     subset.setXYWH(x, y, preScaleW, preScaleH);
                     // And scale
                     // FIXME: Should we have a version of getScaledDimensions that takes a subset
                     // into account?
                     decodeInfo = decodeInfo.makeWH(SkScalarRoundToInt(preScaleW * fScale),
                                                    SkScalarRoundToInt(preScaleH * fScale));
                     size_t rowBytes = decodeInfo.minRowBytes();
                     if (!subsetBm.installPixels(decodeInfo, pixels, rowBytes, colorTable.get(),
-                                                NULL, NULL)) {
+                                                nullptr, nullptr)) {
                         return SkStringPrintf("could not install pixels for %s.", fPath.c_str());
                     }
                     const SkCodec::Result result = codec->getPixels(decodeInfo, pixels, rowBytes,
                             &opts, colorPtr, colorCountPtr);
                     switch (result) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         case SkCodec::kInvalidConversion:
                             if (0 == (x|y)) {
@@ skipping 24 matching lines @@
             }
             return "";
         }
     }
     return "";
 }
 
 SkISize CodecSrc::size() const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     SkAutoTDelete<SkCodec> codec(SkScaledCodec::NewFromData(encoded));
-    if (NULL == codec) {
+    if (nullptr == codec) {
         // scaledCodec not supported, try regular codec
         codec.reset(SkCodec::NewFromData(encoded));
-        if (NULL == codec) {
+        if (nullptr == codec) {
             return SkISize::Make(0, 0);
         }
     }
     SkISize size = codec->getScaledDimensions(fScale);
     return size;
 }
 
 Name CodecSrc::name() const {
     if (1.0f == fScale) {
         return SkOSPath::Basename(fPath.c_str());
@@ skipping 23 matching lines @@
         // Decode the full image.
         SkBitmap bitmap;
         if (!SkImageDecoder::DecodeMemory(encoded->data(), encoded->size(), &bitmap,
                                           dstColorType, SkImageDecoder::kDecodePixels_Mode)) {
             return SkStringPrintf("Couldn't decode %s.", fPath.c_str());
         }
         if (kRGB_565_SkColorType == dstColorType && !bitmap.isOpaque()) {
             // Do not draw a bitmap with alpha to a destination without alpha.
             return Error::Nonfatal("Uninteresting to decode image with alpha into 565.");
         }
-        encoded.reset((SkData*)NULL);  // Might as well drop this when we're done with it.
+        encoded.reset((SkData*)nullptr);  // Might as well drop this when we're done with it.
         canvas->drawBitmap(bitmap, 0,0);
         return "";
     }
     // Decode subsets.  This is a little involved.
     SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(encoded));
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream.get()));
     if (!decoder) {
         return SkStringPrintf("Can't find a good decoder for %s.", fPath.c_str());
     }
     stream->rewind();
@@ skipping 57 matching lines @@
 
 Error SKPSrc::draw(SkCanvas* canvas) const {
     SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
     if (!stream) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
     SkAutoTUnref<SkPicture> pic(SkPicture::CreateFromStream(stream, &lazy_decode_bitmap));
     if (!pic) {
         return SkStringPrintf("Couldn't decode %s as a picture.", fPath.c_str());
     }
-    stream.reset((SkStream*)NULL);  // Might as well drop this when we're done with it.
+    stream.reset((SkStream*)nullptr);  // Might as well drop this when we're done with it.
 
     canvas->clipRect(kSKPViewport);
     canvas->drawPicture(pic);
     return "";
 }
 
 SkISize SKPSrc::size() const {
     SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
     if (!stream) {
         return SkISize::Make(0,0);
@@ skipping 46 matching lines @@
     GrContextFactory factory(options);
     const SkISize size = src.size();
     const SkImageInfo info =
         SkImageInfo::Make(size.width(), size.height(), kN32_SkColorType, kPremul_SkAlphaType);
     SkAutoTUnref<SkSurface> surface(
             NewGpuSurface(&factory, fContextType, fGpuAPI, info, fSampleCount, fUseDFText));
     if (!surface) {
         return "Could not create a surface.";
     }
     if (FLAGS_preAbandonGpuContext) {
-        SkSetErrorCallback(&PreAbandonGpuContextErrorHandler, NULL);
+        SkSetErrorCallback(&PreAbandonGpuContextErrorHandler, nullptr);
         factory.abandonContexts();
     }
     SkCanvas* canvas = surface->getCanvas();
     Error err = src.draw(canvas);
     if (!err.isEmpty()) {
         return err;
     }
     canvas->flush();
     if (FLAGS_gpuStats) {
         canvas->getGrContext()->dumpCacheStats(log);
@@ skipping 24 matching lines @@
         int xPages = ((width - 1) / kLetterWidth) + 1;
         int yPages = ((height - 1) / kLetterHeight) + 1;
 
         for (int y = 0; y < yPages; ++y) {
             for (int x = 0; x < xPages; ++x) {
                 int w = SkTMin(kLetterWidth, width - (x * kLetterWidth));
                 int h = SkTMin(kLetterHeight, height - (y * kLetterHeight));
                 SkCanvas* canvas =
                         doc->beginPage(SkIntToScalar(w), SkIntToScalar(h));
                 if (!canvas) {
-                    return "SkDocument::beginPage(w,h) returned NULL";
+                    return "SkDocument::beginPage(w,h) returned nullptr";
                 }
                 canvas->clipRect(letter);
                 canvas->translate(-letter.width() * x, -letter.height() * y);
                 Error err = src.draw(canvas);
                 if (!err.isEmpty()) {
                     return err;
                 }
                 doc->endPage();
             }
         }
     } else {
         SkCanvas* canvas =
                 doc->beginPage(SkIntToScalar(width), SkIntToScalar(height));
         if (!canvas) {
-            return "SkDocument::beginPage(w,h) returned NULL";
+            return "SkDocument::beginPage(w,h) returned nullptr";
         }
         Error err = src.draw(canvas);
         if (!err.isEmpty()) {
             return err;
         }
         doc->endPage();
     }
     if (!doc->close()) {
         return "SkDocument::close() returned false";
     }
     dst->flush();
     return "";
 }
 
 PDFSink::PDFSink() {}
 
 Error PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
     SkAutoTUnref<SkDocument> doc(SkDocument::CreatePDF(dst));
     if (!doc) {
-        return "SkDocument::CreatePDF() returned NULL";
+        return "SkDocument::CreatePDF() returned nullptr";
     }
     return draw_skdocument(src, doc.get(), dst);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 XPSSink::XPSSink() {}
 
 Error XPSSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
     SkAutoTUnref<SkDocument> doc(SkDocument::CreateXPS(dst));
     if (!doc) {
-        return "SkDocument::CreateXPS() returned NULL";
+        return "SkDocument::CreateXPS() returned nullptr";
     }
     return draw_skdocument(src, doc.get(), dst);
 }
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 SKPSink::SKPSink() {}
 
 Error SKPSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
     SkSize size;
     size = src.size();
@@ skipping 309 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM