Style Change: NULL->nullptr

src/utils/mac/SkCreateCGImageRef.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkCGUtils.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 83 matching lines @@
             return false;
     }
     return true;
 }
 
 static SkBitmap* prepareForImageRef(const SkBitmap& bm,
                                     size_t* bitsPerComponent,
                                     CGBitmapInfo* info) {
     bool upscaleTo32;
     if (!getBitmapInfo(bm, bitsPerComponent, info, &upscaleTo32)) {
-        return NULL;
+        return nullptr;
     }
 
     SkBitmap* copy;
     if (upscaleTo32) {
         copy = new SkBitmap;
         // here we make a ceep copy of the pixels, since CG won't take our
         // 565 directly
         bm.copyTo(copy, kN32_SkColorType);
     } else {
         copy = new SkBitmap(bm);
     }
     return copy;
 }
 
 CGImageRef SkCreateCGImageRefWithColorspace(const SkBitmap& bm,
                                             CGColorSpaceRef colorSpace) {
     size_t bitsPerComponent SK_INIT_TO_AVOID_WARNING;
     CGBitmapInfo info       SK_INIT_TO_AVOID_WARNING;
 
     SkBitmap* bitmap = prepareForImageRef(bm, &bitsPerComponent, &info);
-    if (NULL == bitmap) {
-        return NULL;
+    if (nullptr == bitmap) {
+        return nullptr;
     }
 
     const int w = bitmap->width();
     const int h = bitmap->height();
     const size_t s = bitmap->getSize();
 
     // our provider "owns" the bitmap*, and will take care of deleting it
     // we initially lock it, so we can access the pixels. The bitmap will be deleted in the release
     // proc, which will in turn unlock the pixels
     bitmap->lockPixels();
     CGDataProviderRef dataRef = CGDataProviderCreateWithData(bitmap, bitmap->getPixels(), s,
                                                              SkBitmap_ReleaseInfo);
 
     bool releaseColorSpace = false;
-    if (NULL == colorSpace) {
+    if (nullptr == colorSpace) {
         colorSpace = CGColorSpaceCreateDeviceRGB();
         releaseColorSpace = true;
     }
 
     CGImageRef ref = CGImageCreate(w, h, bitsPerComponent,
                                    bitmap->bytesPerPixel() * 8,
                                    bitmap->rowBytes(), colorSpace, info, dataRef,
-                                   NULL, false, kCGRenderingIntentDefault);
+                                   nullptr, false, kCGRenderingIntentDefault);
 
     if (releaseColorSpace) {
         CGColorSpaceRelease(colorSpace);
     }
     CGDataProviderRelease(dataRef);
     return ref;
 }
 
 void SkCGDrawBitmap(CGContextRef cg, const SkBitmap& bm, float x, float y) {
     CGImageRef img = SkCreateCGImageRef(bm);
@@ skipping 25 matching lines @@
             CGPDFDocumentRelease(fDoc);
         }
     }
 private:
     CGPDFDocumentRef fDoc;
 };
 #define SkAutoPDFRelease(...) SK_REQUIRE_LOCAL_VAR(SkAutoPDFRelease)
 
 bool SkPDFDocumentToBitmap(SkStream* stream, SkBitmap* output) {
     CGDataProviderRef data = SkCreateDataProviderFromStream(stream);
-    if (NULL == data) {
+    if (nullptr == data) {
         return false;
     }
 
     CGPDFDocumentRef pdf = CGPDFDocumentCreateWithProvider(data);
     CGDataProviderRelease(data);
-    if (NULL == pdf) {
+    if (nullptr == pdf) {
         return false;
     }
     SkAutoPDFRelease releaseMe(pdf);
 
     CGPDFPageRef page = CGPDFDocumentGetPage(pdf, 1);
-    if (NULL == page) {
+    if (nullptr == page) {
         return false;
     }
 
     CGRect bounds = CGPDFPageGetBoxRect(page, kCGPDFMediaBox);
 
     int w = (int)CGRectGetWidth(bounds);
     int h = (int)CGRectGetHeight(bounds);
 
     SkBitmap bitmap;
     if (!bitmap.tryAllocN32Pixels(w, h)) {
         return false;
     }
     bitmap.eraseColor(SK_ColorWHITE);
 
     size_t bitsPerComponent;
     CGBitmapInfo info;
-    getBitmapInfo(bitmap, &bitsPerComponent, &info, NULL);
+    getBitmapInfo(bitmap, &bitsPerComponent, &info, nullptr);
 
     CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
     CGContextRef ctx = CGBitmapContextCreate(bitmap.getPixels(), w, h,
                                              bitsPerComponent, bitmap.rowBytes(),
                                              cs, info);
     CGColorSpaceRelease(cs);
 
     if (ctx) {
         CGContextDrawPDFPage(ctx, page);
         CGContextRelease(ctx);
@@ skipping 19 matching lines @@
             cg_bitmap_info = ComputeCGAlphaInfo_BGRA(info.alphaType());
             break;
         default:
             return false;   // no other colortypes are supported (for now)
     }
 
     CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
     CGContextRef cg = CGBitmapContextCreate(pixels, info.width(), info.height(), bitsPerComponent,
                                             rowBytes, cs, cg_bitmap_info);
     CFRelease(cs);
-    if (NULL == cg) {
+    if (nullptr == cg) {
         return false;
     }
 
     // use this blend mode, to avoid having to erase the pixels first, and to avoid CG performing
     // any blending (which could introduce errors and be slower).
     CGContextSetBlendMode(cg, kCGBlendModeCopy);
 
     CGContextDrawImage(cg, CGRectMake(0, 0, info.width(), info.height()), image);
     CGContextRelease(cg);
     return true;
@@ skipping 24 matching lines @@
         default:
             // we don't know if we're opaque or not, so compute it.
             if (SkBitmap::ComputeIsOpaque(tmp)) {
                 tmp.setAlphaType(kOpaque_SkAlphaType);
             }
     }
 
     *dst = tmp;
     return true;
 }