Style Change: NULL->nullptr

src/ports/SkImageDecoder_CG.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCGUtils.h"
 #include "SkColorPriv.h"
 #include "SkImageDecoder.h"
@@ skipping 23 matching lines @@
     SkAutoMalloc storage;
     const size_t len = SkCopyStreamToStorage(&storage, stream);
     void* data = storage.detach();
 
     return CGDataProviderCreateWithData(data, data, len, malloc_release_proc);
 }
 
 static CGImageSourceRef SkStreamToCGImageSource(SkStream* stream) {
     CGDataProviderRef data = SkStreamToDataProvider(stream);
     if (!data) {
-        return NULL;
+        return nullptr;
     }
     CGImageSourceRef imageSrc = CGImageSourceCreateWithDataProvider(data, 0);
     CGDataProviderRelease(data);
     return imageSrc;
 }
 
 class SkImageDecoder_CG : public SkImageDecoder {
 protected:
     virtual Result onDecode(SkStream* stream, SkBitmap* bm, Mode);
 };
@@ skipping 72 matching lines @@
             return !memcmp(CFDataGetBytePtr(data) + ICC_PROFILE_OFFSET_TO_SRGB_TAG, "sRGB", 4);
         }
     }
     return false;
 #endif
 }
 
 SkImageDecoder::Result SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
     CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
 
-    if (NULL == imageSrc) {
+    if (nullptr == imageSrc) {
         return kFailure;
     }
     SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
 
-    CGImageRef image = CGImageSourceCreateImageAtIndex(imageSrc, 0, NULL);
-    if (NULL == image) {
+    CGImageRef image = CGImageSourceCreateImageAtIndex(imageSrc, 0, nullptr);
+    if (nullptr == image) {
         return kFailure;
     }
     SkAutoTCallVProc<CGImage, CGImageRelease> arimage(image);
 
     const int width = SkToInt(CGImageGetWidth(image));
     const int height = SkToInt(CGImageGetHeight(image));
     SkColorProfileType cpType = kLinear_SkColorProfileType;
 
     CGColorSpaceRef cs = CGImageGetColorSpace(image);
     if (cs) {
@@ skipping 12 matching lines @@
             break;
         default:
             break;
     }
 
     bm->setInfo(SkImageInfo::Make(width, height, kN32_SkColorType, at, cpType));
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return kSuccess;
     }
 
-    if (!this->allocPixelRef(bm, NULL)) {
+    if (!this->allocPixelRef(bm, nullptr)) {
         return kFailure;
     }
 
     SkAutoLockPixels alp(*bm);
 
     if (!SkCopyPixelsFromCGImage(bm->info(), bm->rowBytes(), bm->getPixels(), image)) {
         return kFailure;
     }
 
     CGImageAlphaInfo info = CGImageGetAlphaInfo(image);
@@ skipping 25 matching lines @@
     }
     return kSuccess;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 extern SkImageDecoder* image_decoder_from_stream(SkStreamRewindable*);
 
 SkImageDecoder* SkImageDecoder::Factory(SkStreamRewindable* stream) {
     SkImageDecoder* decoder = image_decoder_from_stream(stream);
-    if (NULL == decoder) {
+    if (nullptr == decoder) {
         // If no image decoder specific to the stream exists, use SkImageDecoder_CG.
         return new SkImageDecoder_CG;
     } else {
         return decoder;
     }
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 SkMovie* SkMovie::DecodeStream(SkStreamRewindable* stream) {
-    return NULL;
+    return nullptr;
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 static size_t consumer_put(void* info, const void* buffer, size_t count) {
     SkWStream* stream = reinterpret_cast<SkWStream*>(info);
     return stream->write(buffer, count) ? count : 0;
 }
 
 static void consumer_release(void* info) {
     // we do nothing, since by design we don't "own" the stream (i.e. info)
 }
 
 static CGDataConsumerRef SkStreamToCGDataConsumer(SkWStream* stream) {
     CGDataConsumerCallbacks procs;
     procs.putBytes = consumer_put;
     procs.releaseConsumer = consumer_release;
     // we don't own/reference the stream, so it our consumer must not live
     // longer that our caller's ownership of the stream
     return CGDataConsumerCreate(stream, &procs);
 }
 
 static CGImageDestinationRef SkStreamToImageDestination(SkWStream* stream,
                                                         CFStringRef type) {
     CGDataConsumerRef consumer = SkStreamToCGDataConsumer(stream);
-    if (NULL == consumer) {
-        return NULL;
+    if (nullptr == consumer) {
+        return nullptr;
     }
     SkAutoTCallVProc<const void, CFRelease> arconsumer(consumer);
 
-    return CGImageDestinationCreateWithDataConsumer(consumer, type, 1, NULL);
+    return CGImageDestinationCreateWithDataConsumer(consumer, type, 1, nullptr);
 }
 
 class SkImageEncoder_CG : public SkImageEncoder {
 public:
     SkImageEncoder_CG(Type t) : fType(t) {}
 
 protected:
     virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality);
 
 private:
@@ skipping 34 matching lines @@
                 bm.copyTo(&bitmap8888, kN32_SkColorType);
                 bmPtr = &bitmap8888;
             }
             type = kUTTypePNG;
             break;
         default:
             return false;
     }
 
     CGImageDestinationRef dst = SkStreamToImageDestination(stream, type);
-    if (NULL == dst) {
+    if (nullptr == dst) {
         return false;
     }
     SkAutoTCallVProc<const void, CFRelease> ardst(dst);
 
     CGImageRef image = SkCreateCGImageRef(*bmPtr);
-    if (NULL == image) {
+    if (nullptr == image) {
         return false;
     }
     SkAutoTCallVProc<CGImage, CGImageRelease> agimage(image);
 
-    CGImageDestinationAddImage(dst, image, NULL);
+    CGImageDestinationAddImage(dst, image, nullptr);
     return CGImageDestinationFinalize(dst);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkImageEncoder* sk_imageencoder_cg_factory(SkImageEncoder::Type t) {
     switch (t) {
         case SkImageEncoder::kICO_Type:
         case SkImageEncoder::kBMP_Type:
         case SkImageEncoder::kGIF_Type:
         case SkImageEncoder::kJPEG_Type:
         case SkImageEncoder::kPNG_Type:
             break;
         default:
-            return NULL;
+            return nullptr;
     }
     return new SkImageEncoder_CG(t);
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_imageencoder_cg_factory);
 
 #ifdef SK_BUILD_FOR_IOS
 class SkPNGImageEncoder_IOS : public SkImageEncoder_CG {
 public:
     SkPNGImageEncoder_IOS()
@@ skipping 25 matching lines @@
         if (CFStringCompare(uttype, gFormatConversions[i].fUTType, 0) == kCFCompareEqualTo) {
             return gFormatConversions[i].fFormat;
         }
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageDecoder::Format get_format_cg(SkStreamRewindable* stream) {
     CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
 
-    if (NULL == imageSrc) {
+    if (nullptr == imageSrc) {
         return SkImageDecoder::kUnknown_Format;
     }
 
     SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
     const CFStringRef name = CGImageSourceGetType(imageSrc);
-    if (NULL == name) {
+    if (nullptr == name) {
         return SkImageDecoder::kUnknown_Format;
     }
     return UTType_to_Format(name);
 }
 
 static SkImageDecoder_FormatReg gFormatReg(get_format_cg);