Style Change: NULL->nullptr

src/codec/SkJpegCodec.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 "SkCodec.h"
 #include "SkJpegCodec.h"
 #include "SkJpegDecoderMgr.h"
@@ skipping 98 matching lines @@
     }
 
     // Initialize the decompress info and the source manager
     decoderMgr->init();
 
     // Read the jpeg header
     if (JPEG_HEADER_OK != chromium_jpeg_read_header(decoderMgr->dinfo(), true)) {
         return decoderMgr->returnFalse("read_header");
     }
 
-    if (NULL != codecOut) {
+    if (nullptr != codecOut) {
         // Recommend the color type to decode to
         const SkColorType colorType = decoderMgr->getColorType();
 
         // Create image info object and the codec
         const SkImageInfo& imageInfo = SkImageInfo::Make(decoderMgr->dinfo()->image_width,
                 decoderMgr->dinfo()->image_height, colorType, kOpaque_SkAlphaType);
         *codecOut = new SkJpegCodec(imageInfo, stream, decoderMgr.detach());
     } else {
-        SkASSERT(NULL != decoderMgrOut);
+        SkASSERT(nullptr != decoderMgrOut);
         *decoderMgrOut = decoderMgr.detach();
     }
     return true;
 }
 
 SkCodec* SkJpegCodec::NewFromStream(SkStream* stream) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
-    SkCodec* codec = NULL;
-    if (ReadHeader(stream,  &codec, NULL)) {
+    SkCodec* codec = nullptr;
+    if (ReadHeader(stream,  &codec, nullptr)) {
         // Codec has taken ownership of the stream, we do not need to delete it
         SkASSERT(codec);
         streamDeleter.detach();
         return codec;
     }
-    return NULL;
+    return nullptr;
 }
 
 SkJpegCodec::SkJpegCodec(const SkImageInfo& srcInfo, SkStream* stream,
         JpegDecoderMgr* decoderMgr)
     : INHERITED(srcInfo, stream)
     , fDecoderMgr(decoderMgr)
 {}
 
 /*
  * Return the row bytes of a particular image type and width
@@ skipping 38 matching lines @@
     dinfo.num_components = 0;
     dinfo.scale_num = num;
     dinfo.scale_denom = denom;
     chromium_jpeg_calc_output_dimensions(&dinfo);
 
     // Return the calculated output dimensions for the given scale
     return SkISize::Make(dinfo.output_width, dinfo.output_height);
 }
 
 bool SkJpegCodec::onRewind() {
-    JpegDecoderMgr* decoderMgr = NULL;
-    if (!ReadHeader(this->stream(), NULL, &decoderMgr)) {
+    JpegDecoderMgr* decoderMgr = nullptr;
+    if (!ReadHeader(this->stream(), nullptr, &decoderMgr)) {
         return fDecoderMgr->returnFalse("could not rewind");
     }
-    SkASSERT(NULL != decoderMgr);
+    SkASSERT(nullptr != decoderMgr);
     fDecoderMgr.reset(decoderMgr);
     return true;
 }
 
 /*
  * Checks if the conversion between the input image and the requested output
  * image has been implemented
  * Sets the output color space
  */
 bool SkJpegCodec::setOutputColorSpace(const SkImageInfo& dst) {
@@ skipping 134 matching lines @@
             // behavior is unspecified but SkCodec consistently uses black as
             // the fill color for opaque images.  If the destination is kGray,
             // the low 8 bits of SK_ColorBLACK will be used.  Conveniently,
             // these are zeros, which is the representation for black in kGray.
             // If the destination is kRGB_565, the low 16 bits of SK_ColorBLACK
             // will be used.  Conveniently, these are zeros, which is the
             // representation for black in kRGB_565.
             if (kNo_ZeroInitialized == options.fZeroInitialized ||
                     kN32_SkColorType == dstInfo.colorType()) {
                 SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes, dstHeight - y,
-                        SK_ColorBLACK, NULL);
+                        SK_ColorBLACK, nullptr);
             }
 
             // Prevent libjpeg from failing on incomplete decode
             dinfo->output_scanline = dstHeight;
 
             // Finish the decode and indicate that the input was incomplete.
             chromium_jpeg_finish_decompress(dinfo);
             return fDecoderMgr->returnFailure("Incomplete image data", kIncompleteInput);
         }
 
@@ skipping 46 matching lines @@
                 srcConfig = SkSwizzler::kBGRX;
                 break;
             case kRGB_565_SkColorType:
                 srcConfig = SkSwizzler::kRGB_565;
                 break;
             default:
                 //would have exited before now if the colorType was supported by jpeg
                 SkASSERT(false);
         }
 
-        fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, NULL, info, options.fZeroInitialized, 
+        fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, info, options.fZeroInitialized, 
                                                    this->getInfo()));
         if (!fSwizzler) {
             // FIXME: CreateSwizzler could fail for another reason.
             return SkCodec::kUnimplemented;
         }
         return SkCodec::kSuccess;
     }
 
     SkCodec::Result onStart(const SkImageInfo& dstInfo, const SkCodec::Options& options,
                             SkPMColor ctable[], int* ctableCount) override {
@@ skipping 23 matching lines @@
             }
             // create swizzler for sampling
             SkCodec::Result result = this->initializeSwizzler(dstInfo, options);
             if (SkCodec::kSuccess != result) {
                 SkCodecPrintf("failed to initialize the swizzler.\n");
                 return result;
             }
             fStorage.reset(get_row_bytes(fCodec->fDecoderMgr->dinfo()));
             fSrcRow = static_cast<uint8_t*>(fStorage.get());
         } else {
-            fSrcRow = NULL;
-            fSwizzler.reset(NULL);
+            fSrcRow = nullptr;
+            fSwizzler.reset(nullptr);
         }
 
         // Now, given valid output dimensions, we can start the decompress
         if (!chromium_jpeg_start_decompress(fCodec->fDecoderMgr->dinfo())) {
             SkCodecPrintf("start decompress failed\n");
             return SkCodec::kInvalidInput;
         }
 
         fOpts = options;
 
@@ skipping 28 matching lines @@
         }
 
         for (int y = 0; y < count; y++) {
             // Read row of the image
             uint32_t rowsDecoded =
                     chromium_jpeg_read_scanlines(fCodec->fDecoderMgr->dinfo(), &dstRow, 1);
             if (rowsDecoded != 1) {
                 if (SkCodec::kNo_ZeroInitialized == fOpts.fZeroInitialized ||
                         kN32_SkColorType == this->dstInfo().colorType()) {
                     SkSwizzler::Fill(dstRow, this->dstInfo(), rowBytes,
-                            count - y, SK_ColorBLACK, NULL);
+                            count - y, SK_ColorBLACK, nullptr);
                 }
                 fCodec->fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
                 return SkCodec::kIncompleteInput;
             }
 
             // Convert to RGBA if necessary
             if (JCS_CMYK == fCodec->fDecoderMgr->dinfo()->out_color_space) {
                 convert_CMYK_to_RGBA(dstRow, fCodec->fDecoderMgr->dinfo()->output_width);
             }
 
@@ skipping 40 matching lines @@
     uint8_t*                   fSrcRow;     // Only used if sampling is needed
     SkCodec::Options           fOpts;
     SkAutoTDelete<SkSwizzler>  fSwizzler;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkJpegCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkJpegCodec> codec(static_cast<SkJpegCodec*>(SkJpegCodec::NewFromStream(stream)));
     if (!codec) {
-        return NULL;
+        return nullptr;
     }
 
     const SkImageInfo& srcInfo = codec->getInfo();
 
     // Return the new scanline decoder
     return new SkJpegScanlineDecoder(srcInfo, codec.detach());
 }