Style Change: NULL->nullptr

src/images/SkImageDecoder_libwebp.cpp

 /*
  * Copyright 2010, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
@@ skipping 119 matching lines @@
 //////////////////////////////////////////////////////////////////////////
 
 #ifdef TIME_DECODE
 
 #include "SkTime.h"
 
 class AutoTimeMillis {
 public:
     AutoTimeMillis(const char label[]) :
         fLabel(label) {
-        if (NULL == fLabel) {
+        if (nullptr == fLabel) {
             fLabel = "";
         }
         fNow = SkTime::GetMSecs();
     }
     ~AutoTimeMillis() {
         SkDebugf("---- Time (ms): %s %d\n", fLabel, SkTime::GetMSecs() - fNow);
     }
 private:
     const char* fLabel;
     SkMSec fNow;
@@ skipping 38 matching lines @@
     } else if (ct == kRGB_565_SkColorType) {
         mode = MODE_RGB_565;
     }
     SkASSERT(MODE_LAST != mode);
     return mode;
 }
 
 // Incremental WebP image decoding. Reads input buffer of 64K size iteratively
 // and decodes this block to appropriate color-space as per config object.
 static bool webp_idecode(SkStream* stream, WebPDecoderConfig* config) {
-    WebPIDecoder* idec = WebPIDecode(NULL, 0, config);
-    if (NULL == idec) {
+    WebPIDecoder* idec = WebPIDecode(nullptr, 0, config);
+    if (nullptr == idec) {
         WebPFreeDecBuffer(&config->output);
         return false;
     }
 
     if (!stream->rewind()) {
         SkDebugf("Failed to rewind webp stream!");
         return false;
     }
     const size_t readBufferSize = stream->hasLength() ?
             SkTMin(stream->getLength(), WEBP_IDECODE_BUFFER_SZ) : WEBP_IDECODE_BUFFER_SZ;
     SkAutoMalloc srcStorage(readBufferSize);
     unsigned char* input = (uint8_t*)srcStorage.get();
-    if (NULL == input) {
+    if (nullptr == input) {
         WebPIDelete(idec);
         WebPFreeDecBuffer(&config->output);
         return false;
     }
 
     bool success = true;
     VP8StatusCode status = VP8_STATUS_SUSPENDED;
     do {
         const size_t bytesRead = stream->read(input, readBufferSize);
         if (0 == bytesRead) {
@@ skipping 143 matching lines @@
     if (!directDecode) {
         bitmap = &tmpBitmap;
     }
 
     if (bitmap->isNull()) {
         if (!setDecodeConfig(bitmap, width, height)) {
             return false;
         }
         // alloc from native heap if it is a temp bitmap. (prevent GC)
         bool allocResult = (bitmap == decodedBitmap)
-                               ? allocPixelRef(bitmap, NULL)
+                               ? allocPixelRef(bitmap, nullptr)
                                : bitmap->tryAllocPixels();
         if (!allocResult) {
             return return_false(*decodedBitmap, "allocPixelRef");
         }
     }
 
     SkAutoLockPixels alp(*bitmap);
     WebPDecoderConfig config;
     if (!webp_get_config_resize_crop(&config, bitmap, rect,
                                      this->shouldPremultiply())) {
@@ skipping 30 matching lines @@
     if (!setDecodeConfig(decodedBitmap, sampler.scaledWidth(),
                          sampler.scaledHeight())) {
         return kFailure;
     }
 
     // If only bounds are requested, done
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return kSuccess;
     }
 
-    if (!this->allocPixelRef(decodedBitmap, NULL)) {
+    if (!this->allocPixelRef(decodedBitmap, nullptr)) {
         return return_failure(*decodedBitmap, "allocPixelRef");
     }
 
     SkAutoLockPixels alp(*decodedBitmap);
 
     WebPDecoderConfig config;
     if (!webp_get_config_resize(&config, decodedBitmap, origWidth, origHeight,
                                 this->shouldPremultiply())) {
         return kFailure;
     }
@@ skipping 125 matching lines @@
                 *bpp = 3;
                 return ARGB_4444_To_RGB;
             }
         case kRGB_565_SkColorType:
             *bpp = 3;
             return RGB_565_To_RGB;
         case kIndex_8_SkColorType:
             *bpp = 3;
             return Index8_To_RGB;
         default:
-            return NULL;
+            return nullptr;
     }
 }
 
 static int stream_writer(const uint8_t* data, size_t data_size,
                          const WebPPicture* const picture) {
   SkWStream* const stream = (SkWStream*)picture->custom_ptr;
   return stream->write(data, data_size) ? 1 : 0;
 }
 
 class SkWEBPImageEncoder : public SkImageEncoder {
 protected:
     bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) override;
 
 private:
     typedef SkImageEncoder INHERITED;
 };
 
 bool SkWEBPImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bm,
                                   int quality) {
     const bool hasAlpha = !bm.isOpaque();
     int bpp = -1;
     const ScanlineImporter scanline_import = ChooseImporter(bm.colorType(), hasAlpha, &bpp);
-    if (NULL == scanline_import) {
+    if (nullptr == scanline_import) {
         return false;
     }
     if (-1 == bpp) {
         return false;
     }
 
     SkAutoLockPixels alp(bm);
-    if (NULL == bm.getPixels()) {
+    if (nullptr == bm.getPixels()) {
         return false;
     }
 
     WebPConfig webp_config;
     if (!WebPConfigPreset(&webp_config, WEBP_PRESET_DEFAULT, (float) quality)) {
         return false;
     }
 
     WebPPicture pic;
     WebPPictureInit(&pic);
     pic.width = bm.width();
     pic.height = bm.height();
     pic.writer = stream_writer;
     pic.custom_ptr = (void*)stream;
 
-    const SkPMColor* colors = bm.getColorTable() ? bm.getColorTable()->readColors() : NULL;
+    const SkPMColor* colors = bm.getColorTable() ? bm.getColorTable()->readColors() : nullptr;
     const uint8_t* src = (uint8_t*)bm.getPixels();
     const int rgbStride = pic.width * bpp;
 
     // Import (for each scanline) the bit-map image (in appropriate color-space)
     // to RGB color space.
     uint8_t* rgb = new uint8_t[rgbStride * pic.height];
     for (int y = 0; y < pic.height; ++y) {
         scanline_import(src + y * bm.rowBytes(), rgb + y * rgbStride,
                         pic.width, colors);
     }
@@ skipping 14 matching lines @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
 DEFINE_DECODER_CREATOR(WEBPImageDecoder);
 DEFINE_ENCODER_CREATOR(WEBPImageEncoder);
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkImageDecoder* sk_libwebp_dfactory(SkStreamRewindable* stream) {
     int width, height, hasAlpha;
     if (!webp_parse_header(stream, &width, &height, &hasAlpha)) {
-        return NULL;
+        return nullptr;
     }
 
     // Magic matches, call decoder
     return new SkWEBPImageDecoder;
 }
 
 static SkImageDecoder::Format get_format_webp(SkStreamRewindable* stream) {
     int width, height, hasAlpha;
     if (webp_parse_header(stream, &width, &height, &hasAlpha)) {
         return SkImageDecoder::kWEBP_Format;
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageEncoder* sk_libwebp_efactory(SkImageEncoder::Type t) {
-    return (SkImageEncoder::kWEBP_Type == t) ? new SkWEBPImageEncoder : NULL;
+    return (SkImageEncoder::kWEBP_Type == t) ? new SkWEBPImageEncoder : nullptr;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libwebp_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_webp);
 static SkImageEncoder_EncodeReg gEReg(sk_libwebp_efactory);